A manifesto
Refuse the Flatness
A manifesto on spatial observability, the failure of flat tools to render absence, and the world your software has always lived in.
Published
It's 3 a.m.
Something is wrong. You don't know what yet.
You have forty-seven tabs open across three monitors. Four dashboards. Two terminals. A Slack window with seventeen unread messages from a customer who is, charitably, becoming a former customer. The on-call senior is not responding. The pager is a metronome. The only thing your tools agree on is that something is wrong somewhere.
You are looking at a wall of red and green boxes and trying to remember which service talks to which other service. You drew the diagram once. It was on a whiteboard. It is now on a different whiteboard, in a different office, two jobs ago. The diagram in your head is wrong in ways you can't quite identify. The diagram on the screen does not exist.
Somewhere between two services that both report healthy, a request left one and never arrived at the other. Your dashboard is drawing every service in green because every service is, in fact, in green. The thing that is wrong is the thing that is not on the screen. A flat tool can only draw what it observes. It is, by construction, blind to a request that vanished mid-flight.
This is the job. This has been the job for fifteen years. We have decided, collectively, as a profession, that this is what it looks like to keep software alive.
It does not have to look like this.
We have been working in fog. The tools have sold us blindness as visibility for fifteen years.
Flat tools, flat thinking
The conventional approach to application performance monitoring is not a technology. It is a dogma. It is a set of unexamined beliefs about how engineers should see the systems they are responsible for, dressed up in the vocabulary of telemetry and the user interface of a stock-trading terminal from 2005.
The dogma says: software is rows. Software is charts. Software is panels arranged on a grid, refreshed every fifteen seconds, hyperlinked to other panels arranged on other grids. The dogma says: if you can read enough of these panels, fast enough, you can keep a system alive. The dogma says: the answer to "my system is too complex to understand" is more panels.
The dominant vendors have built genuine infrastructure underneath (distributed tracing, OpenTelemetry, the protocols that made observability a discipline rather than a guess), and they have pointed all of it at a dashboard. They have taken the most powerful telemetry stack ever assembled by an industry and used it to render a flat surface.
You have probably run four or five monitoring tools simultaneously. You have probably lost weeks per year to context-switching between them. Alert fatigue is driving people out of the profession. Mean time to resolution has not meaningfully improved in years. The dogma is failing in plain sight, and the vendors that built it are still selling it, with AI features bolted onto the side like a second jaw.
We are done flattening it.
The thing that isn't on the screen
A flat tool draws what it observes. The dashboard's deepest limitation is not aesthetic and not ergonomic; it is constitutional. A grid of charts can only render the events it received. A request that left one service and never arrived at the next leaves nothing to chart. There is no panel for the message that wasn't there.
Most of the incidents that take engineers the longest to diagnose are absence incidents: the call that never returned, the queue that drained but never refilled, the heartbeat that was missed too quietly. A flat tool is structurally blind to all of them. It can show you the consequence (the latency spike, the error rate, the retry storm) but never the cause (the thing that should have happened and didn't).
A spatial system can render absence because it carries an expectation model. It knows what should have happened, and it shows you the shape of what didn't. The phantom node (the service that should be in the skyline and isn't, the connection that should be carrying traffic and isn't, the request that should have arrived and didn't) is the thing flat tools cannot draw and we built this to draw. We will say more about how, in time. Right now, what matters is the shape of the thing.
This is the part of the system the dashboard was never going to show you. Not because the engineers who built dashboards were careless, but because the medium has no way to render the absence of a thing. The first job of a spatial tool is to put the missing back on the screen.
The screen can now
The dashboard was a 2005 idea. Hardware was weak. Browsers were weak. Bandwidth was scarce. A flat grid of small charts was the best compression of a complex reality the available stack could deliver, and the people who built it deserve real credit for the discipline they invented under hard constraints. Observability, as a category, is one of the genuine architectural achievements of the post-monolith era. We do not dismiss it. We owe it.
What we will not do is pretend it is finished.
Software is not flat. Software has never been flat. Services have topology. Requests have paths. Latency has distance. Failures have neighborhoods. A microservice architecture is not a list of rows in a panel. It is a city, with streets and intersections and rush hours and accidents. Engineers have always known this. We have been compensating for the flatness of our tools by maintaining the three-dimensional model in our heads. We have been carrying our systems' geometry around as a private cognitive burden because the screen could not.
The screen can now.
The hardware that runs AAA video games is the same hardware that sits on most senior engineers' desks. The constraint that produced the dashboard era has been gone for ten years.
Spatial observability is not a feature. It is what the original promise of observability looked like before it was compressed onto a flat surface. It is the un-compression of a high-dimensional reality back into the dimensions it always had.
The world your application has always lived in
Once the absence is on the screen with the presence, the rest of what your application has always been follows. Topology becomes geography. Request paths become routes. Failure neighborhoods become rooms.
Your services are objects in it. Their traffic is light moving between them. Their stress is heat, their failures are wounds, their dependencies are gravity. Time scrubs the whole world, not one chart. When a request enters your system you can watch it fly through, slowing at the slow service, dying at the failing one, the path lit up behind it like a comet's tail.
You navigate by walking. You investigate by approaching. You diagnose by being in the room. Two engineers can stand next to each other in the same instance and point at the same node (actually point, with their actual cursors, at an actual thing they both see) in a way that no Zoom call or shared Grafana tab has ever permitted. The geometry of the system is no longer in your head. It is on the screen, where it belongs, where every member of your team can carry it together.
Spatial observability makes a different kind of AI possible. Not a chatbot bolted onto a sidebar. A presence in the world, with vision and voice, that sees what you see and reasons about it as a place. When you walk toward a failing service it does not return a paragraph about the failing service. It tells you what's happening in the room you are standing in. It points. It follows you. It knows your system because it sees what you see, and it brings its skills (incident patterns, query craft, the shape of failures it has learned to recognize) to the room you are standing in. It does not train on your data. It applies what it already knows to where you already are.
This has to be OpenTelemetry-native. There is no other honest way to build it. We will not lock you in. The same standards the vendors built (the protocols, the data models, the instrumentation conventions), we accept gratefully, take seriously, and refuse to extend with proprietary agents you cannot escape. Your data is yours. Your portability is yours. We will compete on what we build on top of the standards, not on how tightly we can grip your wrists.
We are not the metaverse
The consumer metaverse failed for three structural reasons, all of which we have inverted by construction. It built places without purposes; we built a place because the work was already spatial. It tied itself to VR hardware most people did not want; we ship on the desktop, on the web, and optionally (for the engineers who want the deepest immersion) in VR and on Steam. It promised social value in empty rooms; our rooms are never empty, because the world is populated by your services and your services are always doing something.
The work is the work. We just gave it the geometry it always had.
And the work, like every craft worth doing, deserves a way to be seen.
The credential that measures what you have kept alive
This is the part of the manifesto where we are deliberately not telling you everything.
We will say this much. The profession needs a credential. Not a certification you study for and pass. A credential earned by doing the work, in production, with real stakes, witnessed by the people you helped and the AI that was in the room with you. With tiers. With specialties. Verified in a way that cannot be forged. "Tier 3, K8s Networking, 47 incidents resolved" is a sentence we want to make matter, and the engineers who earn the right to write it on their resumes should find that it travels with them across every job they ever take.
We are building one shape of this. There should be others. The credentials that exist in this industry measure what you have studied, what you have contributed, what you have shared. They do not measure what you have kept alive.
We will say more later. We are building it carefully. We are not in a hurry to ship a marketplace that we will then have to apologize for.
What we will say now is the principle behind it: the people who keep software alive are some of the most skilled craftspeople in any industry, and they have been treated, by their tools and by their employers and by the conventional wisdom of how operations work gets done, like plumbers in a basement. They deserve a hall. They deserve credentials. They deserve a profession with its own visible architecture of expertise, where the senior people are seen, the rising people are mentored, and the work is dignified by the structures that hold it.
We are building that.
Refuse the flatness
There is one more thing we want you to know, and then we will let you go.
We are aware of what this manifesto sounds like. We have read other manifestos. We know the genre. We know that every category-defining founder eventually writes one of these and that most of them are insufferable. We have tried to write one that earns its words.
What we believe is this:
Flatness is not the truth of the system; it is the shape of the tool. The system has always been a place. The tools are catching up. We have built one of the things that catches up. It is shipping. Others have tried. The medium is still open.
If you are an engineer who has been sitting in front of a wall of dashboards for ten years thinking there has to be a better way to do this: you were right. There is. We made it.
If you are a senior who has been telling junior engineers that the diagram in your head is the real system and the panels are just shadows of it: you were right too. The diagram in your head is the system. We just gave it a screen to live on.
If you are tired of context-switching between four tools to answer one question, tired of being woken up at 3am to look at red squares, tired of the suspicion that your industry has been settling for less than the technology can deliver, that suspicion was correct. We have spent years building the alternative. It is shipping. It runs in your browser, on your laptop, in VR if you want it. It is on Steam. It has a thousand small decisions of craft underneath every visible surface, and we are not done. We are just past the point where we are willing to keep building in silence.
Refuse the flatness.
Build what comes next.
#refusetheflatness