We were building a new platform that wasn’t yet in production.
As part of the build, we were also building its observability.
That wasn’t something we planned to add later, once the platform was live. For us, it was part of delivering the platform itself.
The reason was simple.
Eventually, the client’s team would operate it without us.
They needed to be able to answer questions such as:
- What is happening across the platform?
- Where did a request fail?
- What did we send to a downstream provider?
- What came back?
- How do we trace a transaction through the different components?
Without that visibility, we might understand the platform because we built it.
The client would still depend on us to understand it.
Then the Dashboard Showed Us Something
We had spent considerable time thinking about negative paths.
What happens if a provider rejects a request? What happens if something times out? What happens when a response isn’t what we expect?
We tried to anticipate those scenarios and test them.
But while building and testing the dashboards, we encountered behaviour from a downstream provider that we hadn’t accounted for correctly in the application.
The exact scenario wasn’t important.
What mattered was how we found it.
The observability we were building for the client had exposed something about our own system that our existing test scenarios hadn’t.
And this was before the platform was even in production.
The dashboards weren’t only going to help the client investigate problems later. They were already helping us understand the behaviour of the platform while we were building it.
Giving the Client Eyes
Once the dashboards were ready, the work didn’t end there.
We documented what they showed and met with the client’s team to walk through them.
The objective wasn’t to show them something impressive that we had built.
It was to make sure they could use it without us.
Where do you start when investigating a transaction?
How do you follow it through the platform?
How do you distinguish what happened inside the application from what happened at a downstream provider?
Those are things the team operating the platform needs to understand.
Because handing over software without handing over the ability to understand its behaviour leaves a dependency behind.
Observability Is Part of the Platform
We don’t see observability as something that gets added after a platform goes live.
It is part of making a platform operable.
And when we’re eventually no longer the people operating it, the visibility shouldn’t leave with us.
A platform isn’t ready to hand over just because it runs.
The team taking ownership needs to be able to see what it is doing.