Sixty Feet, Six Inches of October

What a little pitch-tracking app saw in the 2026 World Series.

Robert Gasser effectiveness card stats from his Game 3 start on October 26, 2026.

October baseball is a different sport wearing the same uniforms.

In July, a starter gets six innings and a long leash. In October, he gets a hook the moment the third time through the order looks shaky. Aces pitch on short rest. Relievers who were anonymous in June become household names in a week. Managers who spent the summer saving arms spend the fall burning them, because there is no tomorrow to save them for.

Which makes October the most interesting month of the year to watch pitchers. So this year, I watched them twice: once on the couch, and once through a small app I built early this 2026 season to keep tabs on what starters were throwing.

The Brewers won it in five. What the app saw along the way was not quite the Series I thought I was watching.

The app, briefly

It’s a modest thing. You give it a date range, and it pulls every pitch from Statcast, MLB’s pitch-tracking system, figures out who started each game, and shows what those starters threw: pitch mix, velocity, spin, where the pitches crossed the plate, and how often hitters swung through them.

The hosted version caps requests at 14 days so it doesn’t fall over on a free server. That limit turns out to be perfect for this, because an entire World Series fits inside it. Every number in this post came from typing the Series dates into the demo and pressing a button, and you can do the same thing and check my work.

How I’m keeping score

ERA is a lousy stat for a seven-game series. One bad inning can wreck it, and a starter might only make two starts. So for ranking who pitched well, the app uses CSW%: the share of a pitcher’s pitches that end in a called strike or a swing and miss.

It’s a simple idea. A pitch the umpire calls a strike, or one the hitter flails at and misses, is a pitch the pitcher won. A starter who wins a third of his pitches is having a very good night. League average usually lands somewhere in the high twenties.

To keep a pitcher with ten great pitches from topping the list, a starter needs at least 75 pitches across his Series starts to qualify. That’s roughly one full start, and in October, it turns out not everyone gets one.

I should admit something about that number before we go any further, because it shaped everything the app told me.

Seventy-five pitches is not a neutral choice. It’s a number I picked because of the pitchers I grew up watching. Nolan Ryan. Randy Johnson. Tom Glavine. Greg Maddux. Starters who expected to be in the game in the seventh inning and were mildly insulted when they weren’t. The term “Maddux,” for a complete-game shutout thrown in under 100 pitches, exists because one man did it often enough that we needed a word for it.

So when I wrote “at least 75 pitches in his starts” into the code, I wasn’t defining a starter. I was defining the kind of starter I was looking for. The app has been quietly asking a 1995 question of a 2026 game ever since, and the 2026 game kept declining to answer it.

More on that below, because it turned out to be the most interesting thing in the data.

My predictions, written before Game 1

These went up in a separate post before the first pitch, so I couldn’t quietly edit them afterward.

  1. The CSW leader will clear 32%. The Series’ most effective qualifying starter, using the 75-pitch minimum, will finish with a CSW% of at least 32%.
  2. At least one starter won’t qualify. At least one pitcher who starts a World Series game will finish the Series with fewer than 75 pitches thrown as a starter.
  3. A rematch will produce a different arsenal. At least one starter making two Series starts will change the usage rate of one pitch type by 15 percentage points or more between appearances.
  4. Misiorowski will reach 105. Jacob Misiorowski will throw at least one pitch of 105 mph or faster in the Series, per Statcast.
  5. Freddy Peralta won’t lead the CSW rankings. Despite his ALCS MVP performance, Peralta will not finish as the World Series’ highest-CSW qualifying starter.

The most effective starter of the Series

Robert Gasser, Milwaukee. 29.3% CSW, Game 3, 75 pitches.

Seventy-five. Exactly seventy-five. The most effective starter in the 2026 World Series cleared my qualifying threshold by zero pitches. One fewer and the app would have thrown away the best performance it measured.

The line was excellent: 5.1 innings, one hit, one walk, three strikeouts, no runs, an 0.38 WHIP. But the pitch-level data is where it gets strange.

Robert Gasser effectiveness card from his Game 3 start on October 26, 2026.

Gasser threw a 93 mph sinker 41% of the time and an 82 mph sweeper 29% of the time, and leaned on that pair for 70% of his night. The sinker produced a 32.3% CSW. The sweeper, 31.8%. Both comfortably above what anyone else managed.

Here’s the part I had to check twice. Across all 75 pitches, Gasser generated two swinging strikes. Both on the sweeper. His changeup, his cutter, his four-seam, and his sinker, 53 pitches between them, produced zero whiffs.

He led the World Series in a swing-and-miss-adjacent statistic by almost never making anyone miss. Twenty of his twenty-two CSW events were called strikes. He threw an 82 mph breaking ball and a 93 mph sinker at the edges of the zone, umpires kept raising a hand, and Tampa Bay never squared him up.

That isn’t what I expected the leaderboard to look like. It is, however, an extremely Glavine way to spend an evening.

The one who had to grind

Drew Rasmussen, Tampa Bay. 22.5% CSW, 89 pitches, 3.2 innings.

In Game 2, Rasmussen threw more pitches in a single start than anyone else managed all Series and recorded the fewest outs while doing it: eleven. Eighty-nine pitches for eleven outs is 8.1 pitches per out, and the damage followed, with three runs, six hits, two walks, and a 7.36 R/9.

Easy to file that as a bad night and move on. The pitch data says something more interesting.

Rasmussen’s four-seam fastball generated a 17.6% whiff rate, the highest of any pitch thrown by any qualifying starter in the entire Series. His cutter posted a 28.6% CSW. The stuff was not the problem. He threw five different pitch types, and the two that worked couldn’t carry the three that didn’t: his changeup produced a 13.3% CSW, his sinker 16.7%, and his lone curveball was taken for a ball.

This is the fun part of a stat like CSW%: it measures how often a pitcher won the individual battle, not whether the scoreboard cooperated. A pitcher can lose a lot of battles and still win the war, or win the battles and lose the game on one bad hop. Rasmussen owned the single best swing-and-miss pitch in the World Series and finished last among the men the app would rank.

And then he came back out for Game 5.

On three days’ rest, four days after throwing 89 pitches for eleven outs, Rasmussen gave Tampa Bay four innings on 48 pitches. That is four pitches per out, against 8.1 in Game 2. He cut his workload per out in half, on less rest than a starter is supposed to need.

It is, by that measure, the most efficient start anyone made in the 2026 World Series. The app will not rank it, because 48 pitches does not clear my threshold. More on that in a moment.

The workhorse, and the pitchers the app couldn’t rank

The app shows how many pitches each starter threw, and in October that number is its own story.

The Series workhorse was Jacob Misiorowski, with 165 pitches across two starts, 79 in Game 1 and 86 in Game 5. Rasmussen was next with 137, also across two. Nobody else got a second start, and no single start in the entire Series reached 90 pitches.

And now the number that reframed this entire project.

Five games. Ten starting assignments. Five of them reached 75 pitches.

Half the men who threw the first pitch of a World Series game did not throw enough pitches for my app to have an opinion about them. Game 4 is the clean example: Tampa Bay won it in twelve innings, and neither starter qualified. Rasmussen’s Game 5, the most efficient start of the Series, did not qualify either. Forty-eight pitches is not enough to count as a start, according to me.

The app reported none of this. It printed “Most Effective: 4 Starters,” then later “Most Effective: 1 Starters,” and said nothing at all about the ones it had silently discarded. I had to notice the missing cards myself.

That’s a design failure, and it’s mine. A filter that excludes half its population while displaying only the survivors isn’t reporting a result, it’s hiding one. The fix is a line of text: 4 qualifying of 10 starters. I’ve got an issue open to add the count, to make the pitch minimum a form field instead of a constant buried in the code, and to go back to ranking everyone who threw the first pitch of a game.

Because here’s the thing I had backwards. I thought the 75-pitch floor was a sample-size guard, a way to stop a six-pitch opener from topping the leaderboard. It is that. But it’s also a definition, and I wrote it in the image of pitchers who retired before most of this roster was born. The sport didn’t stop producing starters. It stopped producing the specific kind of starter my code was built to recognize.

There are at least three defensible definitions sitting in the same Statcast rows. Whoever threw the first pitch, which is MLB’s. Whoever threw 75 or more, which is mine. And whoever the team actually planned to carry into the sixth inning, which nobody records anywhere. Those produce three different leaderboards from identical data, and the gap between them is the real story of modern pitching.

The pitch of the Series

Across every qualifying starter, the highest whiff rate belonged to Drew Rasmussen’s four-seam fastball: 17.6% on 34 pitches, averaging 96.4 mph.

Drew Rasmussen's Velocity/Spin chart from his Game 2 start on 24 October 2026

A note on how I got there, because the raw leaderboard lies. Peralta threw exactly two sweepers in the Series and got a whiff on one of them, which the app dutifully records as a 50% whiff rate. Misiorowski’s Game 1 curveball shows 16.7% on six pitches. Neither is a finding. Both are small numbers wearing a percentage sign. Applying a 15-pitch floor to individual pitch types leaves Rasmussen’s fastball on top, with Misiorowski’s Game 5 cutter second at 12.5% and Peralta’s changeup third at 12.0%.

There’s something a little poetic about the Series’ best swing-and-miss pitch belonging to its least effective qualifying starter. Stuff is not the same thing as pitching. It never was.

Did anyone change the plan?

A World Series is the one place a starter faces the same lineup twice in about a week. I wondered whether anyone would come back with a different game plan for the rematch.

The Series gave me two testable cases, and they are the two men who started Game 5. Misiorowski faced the Rays lineup in Game 1 and Game 5. Rasmussen faced the Brewers lineup in Game 2 and Game 5.

The app answers the question without any new features: run it on each start’s date separately and compare the pitch mix.

Jacob Misiorowski 2026 World Series

Pitch Game 1 Game 5 Change
4-Seam Fastball 60.8% 66.3% +5.5
Cutter 21.5% 18.6% -2.9
Slider 8.9% 8.1% -0.7
Curveball 7.6% 7.0% -0.6

He didn’t change the plan. He threw the same four-pitch distribution twice, leaning slightly harder on the fastball the second time. The largest move in his arsenal was five and a half percentage points.

And then there’s this. His four-seam averaged 101.083 mph in Game 1 and 101.081 mph in Game 5. Two starts, six days apart, 105 fastballs between them, and the averages differ by two thousandths of a mile per hour. I have no lesson to draw from that. I just think it’s one of the more remarkable things I’ve ever pulled out of a dataset.

Rasmussen is the harder case, and the app makes it harder than it needs to be. His Game 5 came in at 48 pitches, under the qualifying minimum, so he vanishes from the Game 5 leaderboard entirely. The pitch-by-pitch data for that start exists, sitting in the same Statcast rows as everything else in this post, and my own filter is the only reason I can’t put it in a table next to his Game 2. That is the threshold problem biting a second time, on the one comparison I most wanted to make.

What Misiorowski learned between starts

The two Misiorowski starts are nearly identical on the arsenal chart. They are not identical at all on the scoreboard, and the difference is the best thing I took away from this Series.

Game 1 Game 5
Pitches 79 86
Innings 4.1 5.2
Strikeouts 3 2
Runs 1 0
CSW% 26.6% 29.1%
Pitches per inning 18.2 15.2

Game 5 was his best start of the Series by every measure except the one people look at first. He won more individual pitches, worked an inning and a third deeper, allowed nothing, and struck out fewer people.

He’s 24 years old. This season he threw harder than any starter in recorded history, led the majors with 252 strikeouts, and spent the summer in double digits more often than not. The 105 mph fastball I bet on is a real thing he does.

In Game 5 he got two strikeouts and was close to unhittable anyway, because a pop fly and a ground out retire a hitter exactly as thoroughly as a strikeout does, at roughly a third of the pitch cost. Eighteen pitches an inning gets you pulled in the fifth. Fifteen gets you into the sixth. That is the entire difference between the two starts.

I hope somebody in that clubhouse has already told him. Strikeouts are the most fun outs in baseball and the most expensive, and the pitchers who lasted into the eighth inning in the era I grew up on weren’t the ones collecting the most of them. Greg Maddux averaged under six strikeouts per nine innings in several of his best seasons. He was also in the seventh inning on 85 pitches, which is how he got to pitch the seventh.

Misiorowski threw 86 pitches in Game 5 and got 17 outs. That’s the version of him that pitches for fifteen years.

What the app couldn’t see

One honest limitation, and it mattered in this Series.

The app looks at starters. Only starters. Relief appearances are explicitly excluded, even for a pitcher who started another game in the same date range. Which means it watched the 2026 World Series with roughly half the pitching staff edited out of the picture.

Both closers were excellent, and both earned their innings. Tampa Bay’s trouble wasn’t at the back of the bullpen but in the middle of it, in those sixth and seventh inning handoffs where a two-run lead quietly becomes a problem. If you want to understand how the Brewers won this Series, the gap between the two middle-relief corps belongs in that conversation, and I can’t show it to you with a single screenshot.

That’s not false modesty about a side project. It’s the same point as the 75-pitch threshold. I built a tool around a mental model of baseball where the starter is the story and the bullpen is what happens after the story ends. October 2026 does not work that way. The tool is going to need a different shape next season, and I’ve got a list.

Grading my predictions

Two right, three wrong. The wrong ones were more interesting, which is usually how this goes.

1. The CSW leader will clear 32%. WRONG. Gasser led at 29.3%. Nobody came close to 32%, and the entire qualifying field topped out under 30%. I expected a dominant Series from somebody and got a well-pitched one from several people.

2. At least one starter won’t qualify. RIGHT, and more emphatically than I meant it. I was imagining an opener, or one early hook in a big spot. Five of ten starting assignments came in under 75 pitches. I predicted an exception and got a coin flip.

3. A rematch will produce a different arsenal. WRONG, at least on the half of it I can measure. Misiorowski’s biggest change between Game 1 and Game 5 was 5.5 percentage points on his fastball, nowhere near the 15 I called for. Rasmussen’s second start fell below my own pitch minimum, so the app declines to grade the other case at all. And I nearly didn’t get to grade either one. The prediction quietly required a Series long enough for somebody to start twice, which I didn’t notice when I wrote it. Through four games it looked unresolvable. A twelve-inning Rays win in Game 4 is the only reason it has an answer.

4. Misiorowski will reach 105. WRONG, in the most entertaining way available. He opened Game 1 with a 103.5 mph fastball to Yandy Díaz, the fastest pitch ever thrown in a World Series since tracking began in 2008, breaking Aroldis Chapman’s 103.2 from 2016 and obliterating the previous mark for a starter, Noah Syndergaard’s 101.1 from 2015. He threw 30 pitches at 101 or better that night. The stadium board read 103.4 and Statcast read 103.5, which is its own small lesson about which instrument you believe. And the pitch sailed high for ball one. I predicted a number and the Series handed me a record instead.

5. Freddy Peralta won’t lead the CSW rankings. RIGHT. He finished third at 26.4%, behind Gasser and Misiorowski, on the strength of a Game 1 start that was the only one he got.

Notice that 1 and 4 failed in the same direction. I overestimated peak velocity and I overestimated aggregate dominance, in a Series where the most effective starter threw an 82 mph sweeper and generated two swinging strikes all night. The man throwing 103 wasn’t the man leading in CSW.

Here is the thing I keep coming back to. Rank every start in this Series by pitches per out and the top three are Rasmussen’s Game 5 at 4.00, Gasser’s Game 3 at 4.69, and Misiorowski’s Game 5 at 5.06. Both Game 5 starters finished in the top three. The hardest thrower in recorded history and a man working on three days’ rest, on the last night of the season, getting outs more cheaply than anyone had managed all week.

From the scoreboard, this looked like a Series the Brewers controlled. From sixty feet, six inches, it looked like five games decided by pitchers who got ahead in the count and let the hitters do the rest, and by the bullpens that came in behind them and that my app never saw.

The old pitchers I built this thing for would have recognized the first half of that sentence. I’m less sure what they’d make of the second.


Built with

  • pybaseball, a Python library for pulling Statcast data from Baseball Savant
  • pandas for crunching the pitches
  • Flask for the web app
  • Chart.js for the pitch mix, location, and velocity charts
  • Render for free hosting, with a 14-day limit per request that a World Series happens to fit inside

The code is on GitHub, and the demo is live. Put in the Series dates and see what you find. If you spot a pitcher I should have written about, tell me in the comments.

Next season’s list so far: show the excluded count alongside every leaderboard, make the pitch minimum a parameter instead of a constant, rank by whoever actually threw the first pitch, and work out what, if anything, this thing should say about relievers. Suggestions welcome. Apparently I need them.

Facebooktwitterredditlinkedinmail

I Pulled Nine Years of My Own Dev.to Data. The Numbers Were Not What I Expected.

There is an API. It will tell you things about your writing that the dashboard will not.

I have been publishing on Dev.to since April 2017. There is a four-year hole in the middle where I posted almost nothing, and then a return in March 2026 that has produced eighty-six posts in six months.

That shape turns out to be useful. Two distinct bodies of work, on the same account, separated by a gap long enough that the platform itself changed underneath them. A natural experiment I did not set out to run.

What I wanted was simple: a chart of follower growth with my article publication dates overlaid, to see whether particular posts moved the line. What I got instead was a fairly uncomfortable education in which of my numbers mean anything.

The API made all of it possible, and almost nobody seems to use it.

Yes, There Is an API

Base URL is https://dev.to/api`. You generate a key at **Settings → Extensions → DEV Community API Keys**. Most read endpoints for your own data want that key in anapi-key` header.

There is one detail that will silently ruin your afternoon:

headers = {
    "api-key": key,
    # Omit this and you get v0 responses. No error. No warning.
    "accept": "application/vnd.forem.api-v1+json",
    "user-agent": "my-analytics-script/1.0",
}

Without the accept header you are served the older v0 serializer. Nothing fails. The shapes are just quietly different, and you will spend twenty minutes wondering why a documented field is missing.

Trick One: The Default Page Size Is Not the Maximum

The followers endpoint is documented as returning 80 per page. I have a little over eighteen thousand followers, which is 227 round trips.

The v1 pagination range actually runs to 1000. The 80 is a default, not a ceiling:

batch = client.get(
    f"{API_ROOT}/followers/users",
    params={"page": page, "per_page": 1000},
).json()

Nineteen requests instead of 227. Thirty-one seconds instead of however long 227 polite requests would have taken.

A Forem instance can cap per_page lower through an environment variable, so do not hardcode the assumption. Ask for the maximum, then learn the real stride from what comes back:

if page == 1 and len(batch) < requested:
    # Either the server capped us or that is the entire list.
    # Either way, this is the real page size.
    page_size = len(batch)

Rate limiting is real and it is not gentle. Back off on 429, sleep between pages, and checkpoint your merged results to disk every few pages. A long first pull that dies on page 190 should not discard the previous 189.

Trick Two: Follower Dates Reconstruct History You Never Recorded

This is the single most useful thing in the API and it is easy to miss.

/api/followers/users returns a created_at on every follower: the date that person started following you. You do not need to snapshot your follower count daily and wait six months to accumulate a time series. One pull reconstructs the entire curve retroactively, back to your first follower.

from collections import Counter
from datetime import date, timedelta

dates = sorted(
    date.fromisoformat(f["created_at"][:10]) for f in followers
)
cumulative = list(range(1, len(dates) + 1))  # the growth curve, free

weekly = Counter(d - timedelta(days=d.weekday()) for d in dates)

Line chart of cumulative Dev.to followers from 2017 to 2026. The line is nearly flat until March 2026, then rises steeply to about 18,000 by September. Dotted vertical markers show article publication dates. A dashed second line excluding auto-generated usernames tracks noticeably lower

There is a catch worth stating plainly, because it took me a moment to see it. You only receive people who currently follow you. Anyone who followed and later unfollowed has vanished from the dataset. So the curve is “current followers by acquisition date,” not your follower count as it stood on any given day. It increases monotonically by construction and can never show you a decline that actually happened.

For working out which posts drove acquisition, fine. For anything about retention, actively misleading.

Trick Three: The Analytics Endpoints Exist and Are Barely Documented

There is a whole analytics family that most third-party tooling ignores:

/api/analytics/totals               lifetime views, reactions, comments
/api/analytics/historical           daily series over a date range
/api/analytics/past_day             hourly, last 24 hours
/api/analytics/referrers            where the traffic came from
/api/analytics/follower_engagement  follower growth over time
/api/analytics/dashboard            totals + history + top posts, bundled

All accept article_id to scope to a single post. Two things to know.

The responses nest. They are not flat integers:

{"page_views": {"total": 246454, "average_read_time_in_seconds": 306}}

And the historical data degrades as you go back. For my 2017 posts the endpoint returns weekly buckets rather than daily rows, and in aggregate accounts for only about 15% of those posts’ lifetime views. For 2019 it covers 95%. For 2026, 100%.

That matters more than it sounds. I computed a “half-life” for each post, meaning days from publication until it had earned half its views to date. My first attempt confidently reported that several 2017 posts had half-lives around 3,000 days. They do not. The endpoint simply does not remember most of what those posts earned, and dividing a remembered fraction produces a precise, authoritative, meaningless number.

The fix is a coverage gate:

lifetime = article["page_views_count"]
tracked = sum(daily_series.values())

# A series accounting for 15% of a post's views will still yield a
# confident half-life. It will be an artifact of what the endpoint
# retained, not of how the post aged.
if lifetime and tracked < lifetime * 0.8:
    continue

Eighty-two of my 130 posts survive that gate. The median half-life among them is four days.

Line chart showing cumulative percentage of views earned against days since publication, for twelve posts. Most curves rise almost vertically in the first few days and then flatten. A dotted horizontal line marks the fifty percent level, which most curves cross within a week.

Trick Four: Some Metadata Is in the Markdown, Not the JSON

I write multi-part series. None of my posts came back with a collection_id, which is the field you would reach for to group them.

The series are right there in the Dev.to UI. The article serializer just does not include the field.

But /api/articles/me/published returns body_markdown, front matter and all, and the series name is sitting in it:

FRONT_MATTER_SERIES = re.compile(r"^series:\s*(.+?)\s*$", re.M)

def series_name(article):
    body = article.get("body_markdown") or ""
    if not body.lstrip().startswith("---"):
        return None
    parts = body.split("---", 2)
    if len(parts) < 3:
        return None
    match = FRONT_MATTER_SERIES.search(parts[1])
    return match.group(1).strip().strip("\"'") if match else None

General lesson: when a field you expect is absent from the JSON, check whether the source document came back too. It often did.

Line chart plotting lifetime views against part number for five article series. Every line except one descends from part one to part three, losing roughly half to two thirds of its readers.

Trick Five: Comments Arrive Pre-Threaded

/api/comments?a_id={id} returns comments as a tree, with each comment’s replies nested in children. The structure is doing analytical work for free, and flattening it while preserving depth takes about eight lines:

def flatten(nodes, depth=0):
    out = []
    for node in nodes or []:
        out.append({
            "depth": depth,
            "username": (node.get("user") or {}).get("username"),
            "created_at": node.get("created_at"),
            "text": strip_html(node.get("body_html")),
        })
        out.extend(flatten(node.get("children") or [], depth + 1))
    return out

Depth is the metric that matters. Comment count cannot distinguish eight people each saying “great article” from two people arguing with you for four rounds. Maximum thread depth can. One of my posts has a thread 35 levels deep. That is not a comment section, it is a sustained argument, and no count-based metric would have told me it happened.

Scatter plot with comment count on the horizontal axis and maximum thread depth on the vertical. Most points cluster low and left. A few outliers sit high on the vertical axis, indicating deep back-and-forth threads rather than many separate comments.

There is no endpoint for creating comments, incidentally. Replying still requires the browser. Probably deliberate.

What the Data Actually Said

Here is where the exercise stopped being a programming problem.

My follower count is not a readership number. I gained roughly 18,000 followers in 2026. My 2026 posts have 14,300 total views between them. You cannot acquire eighteen thousand followers from fourteen thousand views. The daily rate sits at a median of 136 with no meaningful response to whether I published anything, and about 37% of the usernames carry auto-generated-looking hex or numeric tails. That is reciprocal-follow farming, it is endemic, and it has nothing to do with me. It does mean the chart I originally set out to build could never have answered the question I was asking.

My most-viewed work is nine years old and no longer being read. My 2017 output was MicroPython, NodeMCU, and MongoDB tutorials. Forty-four posts from 2017 to 2019 pulled 32,474 views. Eighty-six posts in 2026 have pulled 14,300. But the daily series tells the other half: my 5,472-view NodeMCU post has had zero views in the last ninety days. Nineteen of my 130 posts are at zero for the quarter. Lifetime counters never decrease, which makes an archive look alive long after it has stopped breathing.

The engagement numbers invert completely. Those big old tutorials run about 2 reactions per thousand views. My 2026 essays run 56 to 72, with one at 71.6 reactions and 63.8 comments per thousand. Across the eras: 44 old posts drew 26 comments total. 86 new posts have drawn 606.

Scatter plot with lifetime views on a logarithmic horizontal axis and reactions per thousand views on the vertical. Older high-traffic posts sit far right and near the bottom. Newer low-traffic posts sit left and high. Red markers indicate posts with no views in the last ninety days.

So one body of work got found and skimmed. The other gets read and argued with. They are different products, and I had been evaluating both with the same number.

Four percent of my traffic is Google. Direct or unknown is 74.5%. Internal Dev.to is 19%. For someone whose best-performing historical content is evergreen reference material, that is the number I find hardest to look at.

What I Would Tell Someone Starting This

Pull the followers once and cache them, because the dates reconstruct years of history you never thought to record. Gate every analytics computation on data coverage, because a partial series will hand you a confident wrong answer rather than an error. Read thread depth instead of comment count. And check body_markdown before concluding a field does not exist.

Mostly, though: separate the metrics that measure distribution from the metrics that measure whether anyone cared. Views, follower counts, and impressions are the first kind. Comment depth, reply rates, and the fact that the same four people keep showing up in your threads are the second.

I spent nine years assuming the first kind was the scoreboard. The API took an evening to tell me otherwise.

Facebooktwitterredditlinkedinmail