From Redesign to Production: The Week Everything Got Instrumented

The weekend as a test bench

Last week was redesign: new design system, bilingual blog, a CV that finally tells the truth. This week was the unglamorous follow-up that actually matters — taking those redesigned sites and making them real: measured, indexed, consented, and shippable. Two repos carried the week, Backend to the Future and TokenMeter, and by Sunday the same word kept showing up in both: instrumentation.

This post crosses two views: what actually shipped, and the why underneath — the idea that the interesting challenge in AI is no longer the model, but everything you need to see it working. Not everything was smooth. Some things broke.

Highlights — what shipped

Backend to the Future went from "looks finished" to "behaves like production."

First, analytics. I wired GA4 through @next/third-parties, but the interesting part wasn't the tag — it was the GDPR constraint. Living in Alicante means gtag cannot fire before explicit consent, so I built a banner that gates Google Analytics entirely: no tracking until the user opts in. I implemented against a placeholder G-XXXXXXXX first, dropped in the real property G-0ZG2B4VPF8 once I'd created the right GA4 application, ran it in dev to watch the banner behave, deployed, and confirmed my own visit showing up in GA4 realtime. Measurement loop closed.

Then I audited that banner against GDPR properly and found three gaps — all fixed on fix/cookie-consent-rgpd: no way to withdraw consent (Article 7.3), no information or policy link, and worst of all Google Fonts loading from Google's CDN before consent, leaking the visitor's IP. Self-hosting the fonts closed the leak. This is the kind of work nobody sees but a regulator absolutely would.

Next, getting indexed. With the domain already verified in Search Console, I shipped the SEO foundation on feat/seo-indexing: sitemap, robots, and metadataBase. Then the richer layer — JSON-LD structured data, an OG image for social previews, and per-post blog URLs so each article is its own indexable page instead of an anchor. I resubmitted the sitemap and requested indexing for the first recap post. Now we wait for Google.

Finally, polish on the blog itself: the top margin was too heavy on both web and mobile, so I cut it roughly in half. And I added imagery — a thumbnail on each blog card and a cover header inside each post. That one took iteration: the left-aligned card image looked wrong on mobile, so I restacked it with the image on top and the text below. Shipped as PR #10, merged and deployed.

Deploys, by the way, are still satisfyingly low-tech: ./deploy.sh runs npm run build and rsyncs out/ straight to the production server. No pipeline theater.

TokenMeter was the heavier lift: two sprints and a war on noisy data.

I ran a full Jira sprint, closed it, started another, and closed that one too. I began by analyzing the board to see what was actually left, then implemented the tickets in order — TKM-54, then TKM-57 folded into the same PR because they were related, with manual smoke tests on the staging team in between. When the remaining UX tickets stopped making sense — the analysis phase already looked solid — I made the call to close them rather than build features nobody needed, and updated the README with the epic's real status. Then a fresh sprint: TKM-62, TKM-65, TKM-63, and finally TKM-64 to close it out.

The most interesting thread was the war on noise. TokenMeter was pulling every LiteLLM model variant — every dated snapshot, every deprecated model, every gpt-4-0314 and claude-3-...-20240307. The pricing table was drowning in versions nobody uses. So I filtered it down to canonical, active models only: dropped the date-suffixed variants, the deprecated models, and the OpenAI "pro" tiers whose extreme pricing was distorting the rankings without reflecting normal usage. A pricing comparison is only useful if the rows are the ones you'd actually pick.

While I was in the table, I made the input-tokens and output-tokens column headers sortable — click to sort ascending/descending with a little up/down arrow. That introduced a regression where sorting got lost after the data cleanup, which I had to chase down and fix. Worth it: a pricing table you can sort by cost is the whole point.

I also fixed a genuine bug: after analyzing a repo, the "popular this week" card on the home page wasn't marking it as analyzed. I analyzed TheAlgorithms/Python by hand and it stubbornly stayed unmarked — a state-not-refreshing problem I traced and fixed, then confirmed the card updates correctly.

I ran /code-review ultra on PR #42 for a deep multi-agent pass before merging, added GA4 to TokenMeter too, and across the week merged a steady stream of PRs, moving each Jira to done as it landed.

The forward-looking piece: I asked what three improvements TokenMeter actually needs, and turned the answer into an epic plus three stories. The headline one is local token counting — estimating model costs with local tokenizers instead of depending on provider APIs, calling the API only as a fallback. That's TokenMeter eating its own dog food: if the product is about understanding token economics, it should compute tokens itself.

The detail worth teaching

Consent is where most analytics integrations get it wrong without realizing. It's easy to think GDPR is satisfied by dropping a banner and not loading gtag until the click. But the real hole was lower down: Google Fonts loading from Google's CDN before consent was already leaking the visitor's IP to Google, banner or not. Real compliance meant self-hosting the fonts, not just governing the analytics tag. The lesson: consent isn't a layer you put on top — it's auditing every outbound network request before the user says yes.

The thread connecting it all

Step back and the week wasn't two separate projects — it was the same discipline applied twice. Both sites got analytics behind proper consent. Both got their data and presentation cleaned up. And TokenMeter's whole reason to exist — measuring the hidden cost of AI — is the same instinct I was applying to my own sites: you can't improve what you can't see. Last week I made things look right. This week I made them observable.

And that idea is bigger than my repos. I'm increasingly less interested in consuming AI products and more interested in understanding how they work underneath. The models are impressive, but the surrounding ecosystem — tokenization, observability, cost tracking, tooling, infrastructure — is where most of the engineering still lives. The opportunity isn't just building better models; it's building better instrumentation around them. What TokenMeter is chasing with local tokenization — refusing to treat token counting as a provider black box — is exactly that.

Lowlights

Not everything was clean. The sortable-columns work broke its own sorting after the model-list cleanup — a reminder that two changes touching the same table will collide if you don't think about ordering. The "popular this week" card silently failing to mark analyzed repos was the kind of stale-state bug that passes a quick glance and only shows up when you actually use the feature like a user would. And SEO has no satisfying ending: I did everything right — sitemap, structured data, indexing requests — and the only honest status is "submitted, now we wait." Indexing is the one part of shipping you can't merge your way out of.

Key takeaways

• Analytics is the easy part; consent done right (withdrawal, policy, no pre-consent IP leaks) is the real work.
• A comparison tool is only as good as its rows — cut deprecated and outlier data before it distorts the signal.
• Two changes on the same component will fight; cleanup and new features need an ordering plan.
• Stale-state bugs survive code review and die under real usage — exercise the feature like a user.
• SEO ships on Google's clock, not yours; do it right and wait.
• The best product instinct is self-applied: I instrumented my sites with the same "measure it" reflex TokenMeter is built on.

What's next

Both sites are now in production with measurement loops running, so the next move is to act on what they tell me — read the GA4 data, watch indexing land, and let real usage steer the roadmap. On TokenMeter, the local-tokenizer epic is the big one: making the tool compute token costs itself instead of trusting provider APIs. The theme is holding from last week — local-first, measured, AI-assisted — and now there's actual data coming back to prove or disprove every decision.