Tom Johnson

You can’t improve an API you can’t see Shorten the feedback loop between cause and effect.

Full article: beyondruntime.substack.com/p/you-cant-i...

If you want to truly understand how your APIs are behaving (or misbehaving), you need a monitoring AND observability strategy that reflects reality.

Most engineering teams think they’re monitoring their APIs.

They have dashboards, logs, maybe a few alerts. But those tools only tell you part of the story, and often only after something’s already gone wrong.

Great API monitoring is knowing that when something breaks, you’ll know where, why, and how to fix it.

99% of debugging time is just trying to get the system to confess.

Is there a better compliment for an engineering manager?

When metrics go red and logs tell half a story, tracing completes the picture From guesswork to precision, distributed tracing gives us tools for debugging in complex environments.

Full article: beyondruntime.substack.com/p/when-metri...

If you only sample at the beginning of a request (head-based sampling), you might miss the error that happened at the end.

Tail-based sampling is heavier, but smarter and increasingly worth the cost on critical paths.

The worst part of a flaky test isn’t that it fails.

It’s that no one trusts it when it passes.

Hooked up a full-stack session replay to Cursor.

Watching it suggest a fix with actual request/response data was… kind of magic.

The moment a bug enters production, every missing trace becomes a tax on your time.

Spent yesterday afternoon breaking the demo app in different ways and recording how we fix it with full-stack replays and AI-assisted suggestions.

It was fun! 😆

Building Better API Integrations: What We’ve Learned If you don’t think about resilience, performance, and long-term maintenance from day one, you’ll pay for it later.

Full article:

systemdesignchronicles.substack.com/p/building-b...

In every system I've worked on, API integrations start out deceptively simple: a few endpoints here, a webhook there. But scale, uptime requirements, and changing business needs reveal the cracks fast.

Here’s the summary of key API integration best practices I recommend every engineering team adopt

In distributed systems, the hardest part of debugging isn’t finding the bug.

It’s figuring out whose responsibility it is to fix it.

An example of how established media gets things COMPLETELY wrong thanks to journalists not understanding what they write about.

No, an "AI agent" you spun up is not by any means "employee." Do they have credentials (to eg allow accessing systems?) Sure! So do CI/CD services, infra services etc

Love the focus on solving for complexity. You could have easily focused on technical debt, but this makes it much more evident how every decision is a trade off.

This is the loop I’m looking to build: Debug. Understand. Fix. Move on.

Teams don’t lose as much time to bugs as to *debugging them*:

• Context switching
• Grepping through logs
• Reproducing flaky issues

Multiplayer: "Don’t worry, we recorded their machine for you.”

▸ Here’s the full-stack session replay with the bug.
▸ Here’s the test script that reproduces it.
▸ Here’s what your AI tool suggests.
▸ Here’s how to fix it.

It only works if those eyeballs can:

‣ Reproduce the issue
‣ See the same stack traces
‣ Share context

Debugging isn’t a solo skill anymore. It’s a team sport.

“Given enough eyeballs, all bugs are shallow.”

That assumes two things:

1. Everyone can see the bug
2. Everyone sees the same thing

In modern systems, both are not guaranteed.

I’m working to make sure Multiplayer turns every issue into a shareable, debuggable, replayable session—with context across the stack.

The hardest part of debugging isn’t spotting the bug.

Well, it is. But it’s not JUST that.

It’s reproducing it. Understanding it. Explaining it.

Distributed systems obey three fundamental laws:

🔧 Murphy’s Law: If there is a wrong way to do something, then someone will do it.

🔥 Sod’s Law: If something can go wrong, it will

💀 Finagle’s Law: Anything that can go wrong, will, at the worst possible moment.

With this browser extension, we give engineering teams a fast entry point into distributed debugging: anyone can capture a bug directly from the browser, with full frontend and backend context.

I’ve seen first hand how much engineering time gets lost trying to reproduce bugs.

What Multiplayer just shipped shortens the feedback loop between discovery and resolution, and it makes hard-to-reproduce bugs testable, explainable, and shareable.

👇 Check it out

The right way to make AI part of your tech strategy Thomas Johnson, a cofounder and CTO, explains the core tenets of AI adoption, how to thoughtfully implement it, and redirect board-level AI-first pushes.

More thoughts on the right way to add AI to your tech strategy in my latest article for @leaddev.com :

leaddev.com/technical-di...

IMO The best AI strategy isn’t about being first.

⚠️ It’s about being right:

• Solve actual pain

• Use real data you already have

• Strengthen what already works

Instead, ask: “Where is your team already high-leverage?”
That’s where AI can actually multiply your effectiveness.