Benjamin Cane
Portrait of Benjamin Cane
Benjamin Cane
November 18, 2026
performance
Hands using a digital caliper to measure a metal part
Photo by Hans Westbeek on Unsplash

If You Don’t Measure Something, You Can’t Improve It

You’d be surprised how often I’ve found myself in engineering discussions asking how often something occurs and getting a blank stare.

Without any measurement, you are operating on vibes alone.

Engineering teams are always looking to improve something: maybe you want to reduce latency, increase system throughput, reduce production incidents, or make a dent in your pull request queue. Yet time and time again, I see teams start changing systems without any way to measure the results. Something might feel faster, or incidents might feel less frequent; but are they?

Before I improve anything, I make sure I can measure it.

Measure to Understand

The first step to improving anything is understanding where you are today.

Take latency as an example. If you want to improve a system's end-to-end response time, start by measuring it.

How long does a single request take? What’s the average? The 90th percentile?

If you don’t even have that measurement, that’s your first step.

Once you know your end-to-end latency, the next question is where requests spend their time. Modern systems—monoliths or microservices—depend on databases, caches, internal microservices, or external APIs. If you don’t measure latency for each dependency, you’re guessing where the bottleneck is.

When you do measure your dependencies, it needs to be actionable. I've seen teams introduce metrics to measure database call latency without providing a way to identify which database calls were responsible.

They knew database calls were a bottleneck, but the application made hundreds of different database calls. Without knowing which queries were slow, they’ve narrowed down the problem without actually identifying what needed to change.

This same principle applies to system health.

I’ve often been pulled into scenarios where a system’s health is poor—production breaks frequently, the team is constantly firefighting, and it feels like things are getting worse.

One of the first things I ask for is a breakdown of incidents, not just the count but also the categories. Knowing whether incidents are increasing or decreasing is useful—but without categorization, you can’t see why the system is failing.

Categorization turns noise into signal.

Identifying Improvement Opportunities

Once you’ve instrumented measurements and understand your current state, you can find opportunities to improve.

If we take our production incidents example, let's say you've had 30 incidents over the past month. After categorizing them, you discover that 20 were caused by filesystems filling up.

Suddenly, you've got a clear opportunity. Address that recurring issue, and you could eliminate the cause of two-thirds of your incidents.

With that data, you can identify patterns and focus your engineering efforts where they'll have the greatest impact.

Without it, teams might spend weeks fixing unrelated issues while the biggest contributor keeps causing problems.

Validation

After you’ve made improvements, how do you know they had a positive impact?

Take our latency example. If you've measured individual database queries, you can compare their latency before and after making changes to the queries or tables.

But you should also look at the end-to-end response time. Making one query faster doesn't necessarily mean you've made the overall system faster.

With our incidents example, you can continue categorizing incidents and compare the results against your original baseline.

Did filesystem-related incidents actually decrease? Did the improvement hold over a comparable period?

If that recurring problem disappears, you can move on to the next major contributor.

Over time, those measurements help you identify whether the changes you've made actually improve the system.

Final Thoughts

Measurement is fundamental to operating any system.

As you build a platform, instrument and measure every major activity: Dependent service calls, Database operations, File writes, etc. And don’t just measure latency; measure the number of calls and whether they worked.

Without this data, you can’t find your choke points.

As you operate the platform, keep tracking incidents and categorizing them. Those patterns will guide your efforts and show whether your changes are making a difference.

Measurement shouldn't be an afterthought. Whether you're building a new system or improving an existing process, you need to understand where you are before you can decide where to go.

One of the first questions I ask when someone tells me they want to improve something is: How will we know it got better? If we can't answer that, the first thing we need to improve is our ability to measure it.

Discuss on LinkedIn Newsletter Back to all posts

More to Read

  • November 11, 2026 How to make technical decisions more objectively architecture
  • November 4, 2026 Microservices can work for low-latency workloads—if you design for it performance
  • October 28, 2026 Production bugs happen. Fix the gap, not just the bug. engineering
  • October 21, 2026 A timeout doesn’t mean an operation failed. It means you don’t know the outcome. reliability
  • October 14, 2026 Sometimes the biggest contributor to latency isn’t processing or network time. It’s waiting for work to start. performance

Practical engineering notes by Benjamin Cane.