When we build a product, the engineers map out the system architecture first. We draw the services, how they connect and what they depend on. The diagram gets reviewed and approved, and then we build.
After that, nobody goes back to update it.
Before long, the diagram is obsolete. Then an auditor comes around and asks to see the system, and we either show them something stale or rush to redraw it. Developers don't like updating diagrams. Most developers don't like documentation at all.
I've been through this enough times that I wanted a different answer. So I built Ritele.
Let the system draw itself
The idea is simple. Your services already send telemetry. Once a service is instrumented, OpenTelemetry traces record the calls it makes to other services, its database queries, the messages it publishes to queues and its requests to third-party APIs. That's the real architecture, written down by the system itself, all the time.
So Ritele takes that telemetry and draws the architecture from it: the actual services, the actual dependencies, and the actual things they connect to.

A Ritele map of a real system. Service names are changed.
Whether you're an engineer, an engineering manager or a CTO, you get visibility into what is actually running. You can see which service talks to which. If a service is connected to something it isn't supposed to be connected to, you see that too, and can make an informed decision about it instead of finding out during an incident or an audit.
Then it grew
A map tells you what is connected. The next questions are always the same: is it healthy, which request was slow, and what happened inside it? So I added tracing, logs and metrics.
Now you can start from the architecture and drill down: click a component and see its health, open the requests behind a number, follow one request through every service it touched and see how long each hop took, then jump to the log lines from that exact span.
After that came the question every team asks before a big launch or a peak season: how much can this architecture actually take? So Ritele can simulate traffic on the architecture it has mapped (this one is on the paid plans). What happens if we get ten times today's requests at peak? Where do the bottlenecks show up first?
What it is now
The goal is one place for observability. If you want to see what is running in your environment, you go to Ritele and it's there. If you need to troubleshoot, it's there too. It runs on your own servers, so your telemetry stays with you.
Over the next few posts in this series I'll walk through each step on a real system with the names changed: from the map, to a component's metrics, to the slow request, to the log line that explains it.
If you've ever presented a stale diagram to an auditor, I'd like to hear how you handled it. Tell me in the comments.
Ritele has a free plan with no time limit: ritele.io
