Who’s Really Following You on Dev.to? A Guide to Analyzing Your Audience

The reason I’m writing this post is to shed some light on an aspect of Dev.to that many of us don’t think twice about: our followers. We put so much effort into creating content, hoping it resonates with readers and builds our community, but have you ever wondered who’s really following you?

In this article, I’ll share the steps I took to analyze my Dev.to followers and what I found. Along the way, you might notice some surprising patterns — things that made me wonder about the authenticity of some of these followers. Could there be “bot-like” activity among them? It’s worth considering, though I’m not here to point fingers. Instead, I want to encourage you to dig into your own follower data and make discoveries for yourself.

Why Analyze Your Audience?

When Dev.to authors look at their followers, they often wonder: Who are they? Are they engaged? Unfortunately, the platform doesn’t give us much insight into follower activity or engagement. That’s what inspired me to create a custom Jupyter notebook for analysis, which I call the Dev.to Audience Analyzer. This notebook helps me extract and analyze data about my followers, revealing insights that aren’t immediately visible on the platform.

With this tool, I could categorize followers based on activity, profile completeness, and other patterns. And let me tell you, some of the findings were… let’s just say, unusual. I didn’t expect to find what I found, but here we are! Let’s walk through how I approached this.

What You Can Learn About Your Followers

When analyzing your audience on Dev.to, there’s quite a bit of information you can gather using Dev.to’s APIs and some light web scraping. By piecing together data from different sources, you can get a clearer picture of your followers’ engagement and activity levels.

Retrieve Your Articles and Followers via the Forem API

The Forem API provides access to several Dev.to entities, including articles and followers.

• Articles: You can retrieve your own published articles with details like titles, tags, publication dates, and engagement stats. This information is available via the API endpoint getUserArticles.

• Followers: You can fetch a list of your followers and see details such as their username, user ID, profile image, and the date they followed you. This information is accessible via the getUserFollowers endpoint.

Here’s an example of the follower data returned by the API:

{

  "type_of": "user_follower",

  "id": 72,

  "created_at": "2023-04-14T14:45:36Z",

  "user_id": 1375,

  "name": "Taylor \"Chrystal\" \:/ Pfannerstill",

  "path": "/username435",

  "username": "username435",

  "profile_image": "/uploads/user/profile_image/1375/11fa0607-0d22-4c3c-b339-490ff1e25e8d.jpeg"

}

Explore Follower Profiles for Additional Insights

Once you have the usernames or IDs of your followers, you can use the getUser endpoint from the API’s v0 version to retrieve more in-depth profile information. This can include their bio, location, GitHub link, and other public profile details, allowing you to assess their profile completeness.

Scrape Profile Pages for Engagement Metrics

In addition to the data available via the API, you can also scrape public profiles to uncover even more metrics. For example, if you look at a profile page like mine or your own, you’ll see additional information that isn’t available through the API:

• Badges: Displays badges earned by the user, which can signal activity and engagement.

• Stats: Shows the number of posts published, comments written, tags followed, and more.

• Recent Activity: Reveals their latest posts or comments, providing further context on their engagement level.

After combining the data from the API and profile pages, I ended up with two main datasets for analysis. One dataset covers my articles, with details like title, created_at, and public_reactions_count. The other is all about my followers, including everything from their username and location to metrics like article_count, comments_count, and even badges they’ve earned. The followers dataset includes both created_at and joined_at columns, which can be a bit confusing—created_at marks when a user followed me, while joined_at is the date they originally joined Dev.to. You can check out the extraction code here on GitHub if you’re curious—it pulls the data into two pandas dataframes.

A word of caution: the Forem API has strict rate limiting, which can make data extraction slow. I tried running extractions in parallel to speed things up, but it often hits the rate limiter and stalls. For reference, pulling data on around 2,500 followers took me about 40 minutes. So, patience is key if you have a larger following!

Getting Started with the Dev.to Audience Analyzer

If you’re interested in analyzing your own followers, you can run the Dev.to Audience Analyzer Jupyter notebook on your local computer. Before diving into the analysis, you’ll need to set up a Python environment to ensure all dependencies are installed correctly.

1. Set up the Python Environment: Follow the README instructions in the project’s GitHub repository to set up a virtual environment, install required libraries, and configure your .env file with your Dev.to API key.

2. Run the Notebook: Once your environment is ready, open analysis.ipynb in Jupyter and execute the cells to extract and analyze your Dev.to follower data. The notebook will guide you through visualizing follower activity, profile completeness, and engagement patterns.

A Deep Dive into My Dev.to Followers

In this chapter, I’m diving into the detailed analysis I did on my own followers. We’ll look at patterns in how engaged they are, how complete their profiles are, and a few odd trends I noticed along the way. But hey, if you’re not up for this deep dive, feel free to jump ahead to the next chapter where I’ll break down the main takeaways!

To start, I wanted to get a sense of how my followers have grown over time and whether there were any noticeable jumps in follower count after publishing new articles. Right now, I have 11 articles and 2,485 followers, so I was curious to see if any specific content was driving these numbers. So, I plotted a bar chart showing new followers by day, with cumulative followers plotted as a line. Each dashed vertical line represents the date of an article publication, making it easy to see if there’s any correlation between publishing content and follower spikes.

Right off the bat, there’s a massive spike around early 2024–03 that stands out — yet, it’s hard to pinpoint which specific article triggered this rush just by looking at this static chart. To dig deeper and see if a particular article caused this jump, I decided to try something more interactive with Plotly for a clearer view.

Now, we can see from this graph that the big spike in followers is actually tied to my article, “My Journey Learning AI for Songwriting: LSTMs and Taylor Swift”. I promoted this particular article on a few external channels, which definitely gave it a boost and attracted a wave of new followers. This kind of insight is useful — it shows how sharing content beyond Dev.to can make a noticeable impact on follower growth.

Next, I wanted to dig a little deeper: how many of my new followers on each article’s publication date were actually new to Dev.to themselves? This is where things started getting interesting. When I looked at the data, I found that an incredible 98.5% of followers who showed up on the day of an article’s release were same-day joiners.

This left me wondering — did these people see my article and decide to join Dev.to on the spot? Or is it the other way around: they joined Dev.to and somehow stumbled upon my article that same day? Either way, the sheer volume of same-day followers was surprising and definitely raised a few questions in my mind about how genuine this engagement might be.

What’s even more intriguing is that these followers who joined Dev.to the same day they followed me didn’t just vanish — they’ve stuck around on the platform. To get a clearer picture of this, I plotted the Distribution of Followers’ Time on Dev.to, showing how long these followers have continued to exist since their join date.

Next, I wanted to dive into the profile attributes of my followers. Do they have just one attribute filled out? A combination of a few? To understand the quality of my follower base, I looked at a range of profile attributes to see how complete or active these profiles are.

The bar chart below shows the number of followers with specific profile attributes, such as:

• Writing comments or articles

• Having badges, a Twitter/GitHub username, a website, or a location listed

• Adding a profile image or a summary

• Following tags on Dev.to

I also flagged “Empty Profiles” — followers who have no activity or profile details at all.

Among my 2,485 followers, everyone has a profile image, which suggests that Dev.to likely assigns a default image. This means the profile image attribute doesn’t provide meaningful insights for this analysis.

Interestingly, most followers also follow tags. However, since I can’t access details about the specific tags they follow, this attribute doesn’t offer much actionable insight.

Next, I looked at followers who have only one attribute filled out in their profiles. This part of the analysis helps identify which minimal profile details are most common among followers who may not be deeply engaged.

The bar chart highlights the number of followers who have just one attribute as their only profile detail — such as only a GitHub username, only following tags, or only listing a location.

• Only Follow Tags: A large group (530 followers) has only the “follow tags” attribute. As I mentioned before, since I can’t dive into the specific tags they follow, I decided to exclude this group from further analysis.

• Only Badges: Another interesting group — 24 followers — only have badges listed and no other profile information. This seemed unusual and raised some red flags, so I decided to take a closer look at these followers by analyzing their badge distribution.

To dig into follower activity a bit more, I looked at the distribution of badges among my followers. The bar chart above shows the top 10 most common badges, with the “One Year Club” badge dominating the list.

But here’s the thing: these X-Year Club badges (like “One Year Club” or “Two Year Club”) don’t actually say much about follower activity. They’re awarded just for sticking around on Dev.to for a certain amount of time — not for engaging or contributing. So, they’re not exactly useful for figuring out how active my followers really are.

Because of that, I decided to drop these X-Year Club badges from my analysis. They don’t really add any insight into what my followers are actually doing on the platform.

With the X-Year Club badges out of the way, we can see the top 10 active badges among my followers. These badges show real engagement — like the Writing Debut for publishing a first article, Community Wellness Streaks for consistent activity, and Hacktoberfest Pledge for event participation. This gives us a better look at followers who are actually active on Dev.to, not just hanging around.

With the X-Year Club badges out of the way, we get a better look at followers who are actually active on Dev.to, not just hanging around. But badges alone don’t tell the full story. I also looked at how many followers link to external profiles like GitHub, Twitter, or a personal website. Turns out, the majority only list their GitHub, which makes sense given the tech-heavy crowd. A smaller number include a personal website or Twitter, and only a handful link multiple platforms.

When it comes to activity within Dev.to, some of my engaged followers have a mix of badges and articles, with a few going all-in by writing, commenting, and collecting badges. This gives a clearer view of who’s genuinely contributing versus those who might just be lingering without much engagement.

Then I took a look at where my followers are coming from. The chart shows the top 10 locations listed in follower profiles (excluding those who left it blank). India tops the list, followed by the USA and Brazil. Beyond that, locations are scattered, with a few mentions from places like Paris, Ho Chi Minh City, and Bali. Not exactly a huge global spread, but it’s interesting to see some geographic variety in the mix.

After checking out where my followers are from, I wanted to dive into the articles they’ve written. To keep things focused, I filtered out ultra-short posts (less than 1 minute of reading time). These are usually quick intros like “Hi, this is my first article” and don’t add much to the analysis.

Here’s what I did:

1. Filtered the Articles: Kept only articles with a reading time of over 1 minute.

2. Updated the Data: Replaced each follower’s article data with this filtered list of more substantial posts.

3. Recalculated the Counts: Adjusted the article count based on these longer, more meaningful posts.

Now let’s look at the trends in their article counts, average reading times, and the most popular tags they’re writing about.

Looking at the data, it’s clear that most followers have published only a handful of articles — usually fewer than five. Very few have more than 10 articles, suggesting that consistent publishing is pretty rare. As for article length, the average reading time for most followers sits between 2 and 5 minutes, so these tend to be short, quick reads. Only a handful of followers write longer pieces with an average reading time over 10 minutes.

When it comes to tags, certain themes stand out. The most popular tags are “beginners,” “webdev,” and “programming,” showing a focus on foundational topics. There’s also strong interest in specific areas like “python,” “javascript,” “ai,” and “devops,” which speaks to a more technical audience. And with tags like “learning” and “tutorial,” it’s clear that a lot of followers are creating content aimed at teaching or sharing knowledge.

To dig a bit deeper, I looked at followers who haven’t published any articles but have left comments. As you can see in the chart, most of these followers have left only a handful of comments, with the majority sitting at fewer than five. There are a few outliers who’ve commented more frequently, but they’re definitely the exception. This suggests that for many followers, engagement on Dev.to is pretty minimal — they’re not publishing content, and they’re not super active in discussions either.

After digging into follower activity, I decided to break them down into four main categories to get a clearer view of who’s actually active:

1. Active Contributors: Those writing articles or leaving comments.

2. Connected Profiles: People with external links (GitHub, Twitter, etc.) but not much else.

3. Basic Profiles: Minimal info, like a location or summary — no articles, no links.

4. Empty Profiles: Nothing meaningful at all — just blank profiles.

The bar chart on the left shows the numbers for each group, and the donut chart on the right gives the percentage breakdown. This helps show the balance between active followers and those just lurking.

What stands out is that a big chunk of my followers — 30% — are completely empty profiles, and another 10% are “basic” profiles with minimal info but no real engagement. So, in the end, I’m left with 54.4% who at least have external links like GitHub or Twitter, but only a small 5.4% are actually active contributors on Dev.to, either writing articles or leaving comments.

To dig deeper, I looked at how many followers joined Dev.to on the exact same day they started following me. In the chart, Same Day Joiners (in light coral) are those who joined Dev.to and followed me on the same day, while Other Joiners (in teal) were already on the platform.

The result? Almost all of Empty and Basic Profiles are same-day joiners, which makes me wonder if these new followers with minimal profiles are truly engaged users — or just passing through.

To see which articles really grabbed attention, I looked at the follower growth each one sparked within 14 days of being published, broken down by follower type.

In the chart, each bar shows how many new followers each article brought in across the four categories — Active Contributors, Connected Profiles, Basic Profiles, and Empty Profiles. Interestingly, the articles that attracted Active Contributors — the followers who actually engage on Dev.to — were the ones I promoted through external channels. Reaching beyond Dev.to seems to pull in more genuinely active followers from dev.to rather than just passive profiles, showing the value of sharing content outside the platform to attract readers who are more inclined to engage and contribute.

Seeing that the “My Journey Learning…” article attracted a wave of Connected Profiles, most of whom had GitHub links, I decided to dig deeper into these GitHub-connected followers. Since nearly half of my followers have only a GitHub profile connected, it felt like a good area to explore.

First, I set up access to the GitHub API to pull some basic info about their profiles. Here’s what I found:

• Minimal Engagement: 8 followers joined Dev.to on the same day their GitHub was created and last updated, with zero public repos. This suggests these accounts might have been created for following or limited use only.

• New Accounts: 19 followers joined Dev.to on the same day they created their GitHub accounts, but without looking at their last activity date.

• No Public Repos: A total of 110 followers in this group have zero public repos, which could mean they’re either inactive on GitHub or keep their work private.

In the breakdown above, the charts show three categories of GitHub activity status:

1. Active: A good portion (over 74%) show signs of activity with multiple public repos and recent updates.

2. Non-Active: About 22.7% have GitHub accounts but lack visible engagement, with few or no public repos.

3. None: For a tiny fraction provided GitHub profiles weren’t found.

This analysis shows that while many followers with GitHub links are genuinely active, a significant chunk either has minimal presence or no public-facing activity.

To get a better sense of GitHub activity among my followers, I looked at the number of public repositories each user has. Since a few followers have an unusually high number of repos, I applied a cutoff at the 98th percentile to keep the analysis focused on typical users.

This scatter plot gives us a clearer picture: most followers have a modest number of public repos, with only a handful showing extremely high activity on GitHub. This suggests that while there are some power users, the average follower isn’t as intensely active on GitHub, which aligns with general user trends.

Interpreting the Results

Looking at my analysis, a few things jump out that really make me wonder what’s going on:

1. Same-Day Joiners: Apparently, my articles are getting people to join Dev.to and follow me right away, but I’m not really pulling in established, active users. The big question here is, what else are these new followers doing on Dev.to? Are they following anyone else, or is it just me? Are they truly interested or just part of some mass-following trend?

2. Bare-Bones Profiles: A surprising number of my followers have nearly empty profiles. If I filter out these “clean” profiles and the non-active GitHub users, I’m left with only about 1,200 potentially real followers out of my nearly 2,500. It’s like half of my follower count might be smoke and mirrors.

3. Views vs. Followers Puzzle: Here’s where it gets really strange. If you look at the New Followers by Category within 14 Days of Each Article graph, you’ll notice that articles like My Journey Learning AI for Songwriting brought in a massive number of followers — over 1,200 within just two weeks.

Now, you’d think that such a surge in followers would mean equally impressive view counts. But when I checked the Total Views per Article on Dev.to graph, I saw a completely different story. The article only had around 342 views, which doesn’t match up with the flood of followers.

This raises some intriguing questions. Are these followers truly reading my content, or is there something else at play here? Are they mass-followers, or could some of them even be bots? This mismatch between views and followers has me thinking there might be more to uncover — maybe in Dev.to’s metrics or even among my own followers. While I don’t have the data to answer all these questions, this analysis has certainly made me want to look deeper, and I hope it inspires others to dive into their own audience stats as well.

Encouraging a Broader Look

So, what did I learn from all this? For one, follower numbers don’t always tell the full story. It’s one thing to have a large follower count, but it’s quite another to have engaged, active followers who truly value your content. While my analysis left me with more questions than answers, I’m curious to hear what other Dev.to authors find in their own follower analysis.

Could some of our followers be bots? Maybe. Could they be inactive accounts? Possibly. Ultimately, these insights have given me a fresh perspective on follower metrics, and I encourage you to do the same with your audience.

If you’re curious to dig into your own Dev.to followers, you can find my full analysis and code in the repo here: Dev.to Audience Analyzer.