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 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 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 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 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.
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.
for a clearer view.
. 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.
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.
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.
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.
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.
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.
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.
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.
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:
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?
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.
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.
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.
SOCIAL SHARE CARD GENERATOR