Reality: Your Architecture Diagram Comes Alive

Be honest. When did you last trust your architecture diagram?

Every diagram is true exactly once — the day someone drew it. Then production moves on. A service ships. A database gets a replica. Someone wires up a new queue at 11pm. The diagram doesn't move with it. Six months later it's a museum piece: beautiful, detailed, and quietly wrong.

The gap between the picture and production is where incidents hide, where onboarding goes sideways, and where "wait, what talks to the payments database?" gets asked at the worst possible moment.

Today we're closing that gap. Meet Reality.

See what's actually running

Reality connects your live production systems and discovers what's really there — the services, the databases, the dependencies — then lines them up against your curated C4 model. Your diagram stops being a snapshot and starts being a mirror.

Flip on the Reality lens and the canvas comes alive: the elements backed by something running in production light up with a live health dot. The things production is doing that your model never knew about? They show up too, waiting for you to decide what to do with them.

Bring your own source

You're probably already running the tools Reality reads from. No new agent, no exporter to wire up, no code to instrument:

• Kubernetes — a read-only token, and Reality enumerates your workloads and discovers their wiring straight from cluster config.
• Datadog — point it at your APM service map. You get the real dependency graph, including the databases and queues Datadog already infers for you.
• New Relic — read your APM and OpenTelemetry services and their call relationships.

Connect a source once in your organization, and any project can use it. Got a mix? Run all three. Use none and stick to the model — Reality is there when you want it.

Discover, then decide — nothing happens behind your back

Here's the part that matters: Reality never touches your production systems, and it never edits your architecture on its own.

Scanning is read-only. Everything it finds is a proposal. New service running in production but not on your diagram? Reality surfaces it — you choose to promote it into your model, bind it to an element you already have, or ignore it. Discovered a real dependency between two services? Promote it and it's drawn as a relationship. Your model stays yours; you approve every single change, and everything is reversible.

It's organized into a simple inbox:

• Unmodeled — running in production, not yet on your map.
• Drifted — on your map, but production diverged.
• In your model — confirmed matches.
• Orphan — on your map, but nowhere in production.

Work the list, and your diagram converges on the truth.

Why this changes things

A diagram you can trust is a different tool entirely. New engineers see what really exists, not what someone meant to build. Reviews catch the undocumented call to the payments database. The "is this still used?" question has an answer. And because the relationships carry their origin — observed from real telemetry versus derived from config — you know exactly how much to trust each line.

This is the start of the living diagram: architecture that keeps pace with production instead of falling behind it.

Try it

Open any project, hit Reality in the toolbar, connect a source, and scan. In a couple of minutes you'll see your real architecture reconciled against your model — and you'll probably find a thing or two you forgot was running.

Full walkthrough is in the Production Reality docs. Go see what your production is actually doing.