Mental models and software architecture: Why docs aren't the system

I spent three hours last week staring at a sequence diagram that promised a clean, asynchronous handoff between our order service and the inventory module. According to the document, the system used a simple message queue with a 50ms latency expectation. In reality, the production logs showed the process hanging for nearly 1.2 seconds because of a hidden synchronous validation step that someone added in a hotfix two months ago.

That’s the Map-Territory fallacy in action. We treat our abstractions as if they are the truth, forgetting that the documentation is just a representation, not the system itself.

Why mental models drift from reality

When we build software, we rely heavily on mental models to manage complexity. We create diagrams, write RFCs, and maintain READMEs to summarize how things work. But these artifacts are static, while production is a living, breathing creature.

The divergence happens because of "technical drift." Every time a developer pushes a PR that bypasses a validation layer or adds a side-effect, the "territory"—your production code—changes. If the "map"—your documentation—doesn't change with it, the gap widens.

I’ve found that relying on mental models for software engineering to build better systems is essential, but only if you hold those models loosely. If you treat your architectural diagrams as immutable laws, you’ll be blind to the reality of the system when things inevitably break.

The failure of abstraction layers

We use abstraction layers to hide complexity, which is necessary for human cognition. However, these layers often deceive us. We assume that if we call processPayment(), it magically handles everything as described in the API spec.

We first tried to solve this by forcing developers to update confluence pages during every sprint. It failed miserably. Developers view documentation as a chore, so it becomes outdated within weeks. We eventually realized that if documentation isn't generated from code or enforced by tests, it’s basically fiction.

Instead of writing more prose, we started moving toward "living documentation." We use tools like OpenAPI specs (v3.0.3) that generate client libraries directly from our source code. If the code changes, the contract changes. It forces the reality of the system to remain synchronized with the documentation.

Systems thinking in production

To bridge the gap between map and territory, you need to cultivate systems thinking. This means viewing your architecture not as a set of static boxes and arrows, but as a series of feedback loops and potential failure states.

When debugging, I often use first principles thinking for debugging complex software systems to strip away the assumptions I’ve built from reading the docs. You have to ask: "What does the code actually do right now?" rather than "What does the architecture diagram say it should do?"

Consider these three habits to keep your models grounded:

1. Instrumentation as documentation: If you can't see the state of a service in your observability platform (like Grafana or Datadog), your documentation is lying to you.
2. Automated contract testing: Use a tool like Pact to ensure that the "territory" (consumer/provider communication) matches the "map" (your defined contract).
3. Inversion thinking: Sometimes, you have to look at how a system fails to understand how it works. Practicing inversion thinking: how to debug architectural failures faster helps you identify those hidden synchronous blocks that diagrams usually omit.

The reality of architecture

The Map-Territory fallacy is a constant tension. You cannot map every single instruction execution; the map would be as large as the territory. The goal isn't to document everything perfectly, but to maintain a high-fidelity model of the critical paths.

I’m still not convinced that we’ll ever fully solve this. As long as software is written by humans under pressure, there will be shortcuts, "temporary" hacks, and forgotten configurations. I’ve learned to embrace the fact that the documentation is a guide, not a source of truth. The source of truth is always the production environment.

Next time you're deep in a refactor, don't just look at the diagram. SSH into the node, check the actual config files, and look at the real-time telemetry. Your map is helpful, but the territory is where you’ll actually find the bugs.

FAQ

Q: Should I stop writing documentation altogether? A: Absolutely not. Documentation is for communication and onboarding, not for describing the exact state of every line of code. Write docs for the "why" and the "how," and let code and telemetry handle the "what."

Q: How do I know if my mental models are outdated? A: They are outdated the moment you write them down. If you notice yourself saying "it should be doing X" while looking at a log that shows "Y," your model has drifted. Use that moment to update the model or fix the code.

Q: Is there a tool that perfectly aligns docs and code? A: No tool is perfect, but static analysis and schema-driven development (like using a Schema Registry for API contracts) get you much closer than manual updates ever will.