Refuse the Flatness

Refuse what, exactly

Be precise about the enemy, because the lazy version of this argument is wrong and every engineer reading this knows it.

The flat tools are not blind. A modern service map shows relationships, situates a dead node in its neighborhood, highlights what a failing service calls. Anyone claiming a dashboard cannot draw a red node among gray ones has not opened one lately, and the reader with a service map in the next tab stops listening the moment the claim is made. Preattentive vision, the pop-out effect Anne Treisman mapped decades ago, finds one red hexagon in a field of gray in under a second on a flat screen, and a third dimension would mostly give it somewhere to hide. If "flatness" meant the count of dimensions, it was never worth refusing.

It means something else: the refusal to keep any state where your attention lives. The map is a photograph of the last fifteen minutes, so the shape you study is one the system has already left. The stream moves at the data's speed, not yours, and the only way to study it is to pause it and fall behind the present. The filter you write to survive the flood is a chore you babysit mid-incident. Navigate away and back, and your investigation is gone, because it was never a place, only a query that ran. A pinned dashboard survives, but it remembers its own panels, not where you were standing or what you had already ruled out. Everywhere the engineer actually stands, the flat paradigm holds the artifact and forgets the session.

That is the real complaint under the whiteboard you keep redrawing at every job. Not that the tool cannot see. That it cannot hold, so you hold it, in your head, at 3 a.m., which was never the job.

Spatial means where you are

The problems of Berlin matter more to the people who are in Berlin. Nobody has to love the city or even have chosen it. Standing in it is enough, because from where you stand some things are near and most are not, and nearness is the first fact that sorts what matters from what does not. A pager rotation puts you at a node the way a posting puts you in a city: not chosen, and structuring your relevance all the same. Language runs on this. Here, this, now: words that mean nothing without a position. Spatial observability is that ordering applied to a running system. Where you stand determines what matters.

This is not a rejection of the query. The sharpest flat tools made interrogation their whole creed, and rightly: an incident is a question, often one nobody thought to ask until it mattered, and no pre-built view answers a question it was not built for. That creed is sound, and a place does not defeat it. A place is where a question lands and stays answered. A WHERE clause is a position too, a neighborhood you stand in for exactly as long as you keep it typed. It must be re-declared every time, it evaporates when you look away, and a machine can at most read it, because it lives in your text box, not in the world. Declared locality is a sentence you keep repeating. Occupied locality is a room you are in.

Then why call it spatial and not simply stateful, if state is the substrate? Because position is what addresses the state. Where you stand is how the system decides what is relevant to you, what your partner sees, what a frozen moment gathers, the same way here and near decide it in a city. State is what persists; position is how you and the machine agree on which slice of it matters right now. Strip the position and what remains is a database with good uptime. The spatial part is not the rendering and not the storage. It is the addressing.

So the word carries no geometry. It stays true in three dimensions, in two, or as a line of text that reads: you are at the payments service; upstream, checkout has gone quiet.

Three tests

An idea that cannot exclude anything is a mood. So here is the definition with teeth, three tests any tool either passes or fails, whatever it renders:

Identity. Does the tool know that the payments service today is the same thing as the payments service last Tuesday, independent of where any layout happens to draw it, so that returning to it twice is a comparison and not a coincidence?

Neighborhood. Does standing at a node scope the view and the data by itself, with what counts as near already in frame, no filter written, no filter babysat?

Session. Does your position, and what you have already ruled out, survive navigation, persist across the incident, and remain readable by the machine partner working beside you?

Pass all three and the tool is spatial in the sense meant here, even if it renders as text. Fail them and it is flat, however many dimensions it draws. By these tests the prettiest 3D flythrough ever demoed is flat, and that is the point.

What a place can hold

Give the engineer a place to stand and four things become possible that a stateless surface does not natively hold.

The map moves because the system moves. Do not expect to memorize it. Services come and go, the shape reflows, and the layout is not fixed, on purpose. A diagram you can learn by heart is one that has stopped tracking reality, and a pinned board is stable precisely because it froze, going quietly wrong the moment the system moves on without it. What persists is not a coordinate but a relationship. The payments service may sit anywhere on screen; its callers and dependencies are always the neighborhood around it. That is where absence becomes legible. The service that should be calling this one and today is not shows up as a gap in the cluster it belonged to, wherever the physics placed that cluster. You do not find the phantom by remembering where it was. You find it because the ones still alive are standing around the hole.

The obvious objection is that systems go quiet all the time. A deploy, an autoscale down, a lull in traffic, and a naive tool would cry loss over every one. So absence is not declared on the first missed beat. A peer that stops answering is held unresolved, and only after it has stayed gone long enough does the gap harden into a phantom, drawn as the black hole among its live callers; a blip under that threshold never fires. And the hole is not a verdict. If the missing peer comes back, the gap closes and the node returns to what it was, because a phantom is a live inference that can still resolve, not a headstone. The reason it cannot be graded true-or-false in the moment is the honest part: nothing was ever instrumented there, the thing is known only from the callers still reaching for it, and that unknowability is the signal, not a defect in it. The contrast is what makes it readable. A real service that goes idle loses its color as its edges decay, then is pruned away and simply gone. A phantom does not fade like that, because it was never traffic to begin with; the black hole stays lit among the living until a real peer wakes it or the pruner clears it. A thing that fades and disappears was here and left. A thing that stays dark was never here and is being called anyway.

Where you are is what you are asking. Standing somewhere is a statement of intent, the way pointing is. Arrive at a node and its neighborhood is already in view, already scoped. The partner beside you knows what you are looking at for the reason a colleague in the same room does: your position is the context, a thing it reads, not a paragraph you paste into a box. A sidebar assistant has no idea where your eyes are. Here, where you stand is the question, and it is shared.

The now holds still while staying now. The flat tools force a choice: the map is legible but past, the stream is present but running away faster than you can follow, forgetting everything as it scrolls. Pausing helps, but a pause is not a place; the state you froze recedes the instant you resume, because it was a feed you interrupted, not a room you stayed in. A place does not scroll. The service stays put, and what is live is its state, changing in the one spot you are watching. Traffic arriving, thinning, stopping, held where it stopped. You do not query whether it is still happening. You watch it stop.

A moment can be reconstructed around you. Here the flat paradigm has its best answer, and it deserves naming: the distributed trace, a real join of every span of one request in order, the closest the old tools come to a moment held still. A trace is one request's thread. What it cannot give you is the neighborhood around that thread while it broke, every other actor at once; and a date picker gives the opposite gap, six panels aggregating separately while you perform the join in your head. Stand at the failing service and freeze, and its neighborhood assembles itself: the queue backing up while the deploy rolled and checkout went quiet, each in its place, so whoever arrives brings judgment and finds the rest already gathered. Because a service keeps its identity even as its position drifts, two moments compare by returning to it twice, this node now and last Tuesday beside it.

One honest wall stands inside that last property, and it does not fall to a nice sentence. A distributed system has no single instant. Clocks skew, events arrive out of order, ingestion lags, sampling drops some events entirely, so any frozen scene is a constructed cut, stitched from readings that never happened at once. Usually the stitch is close enough to be true. In the microsecond races where you most want to stop time, it is not, and a scene that hid its stitching there would lie at the worst possible moment. The cut must show its seams. Whether it holds at real cardinality is not settled here; it is a debt, listed below with the others.

The partner in the room

The machine beside you is not a chatbot in a sidebar, and now that position is defined, its role can be said exactly.

Its view is your neighborhood, because your position scopes it. Its knowledge is what is live and recorded where you stand. And it proposes the only way a partner in a place can: by pointing. It marks a spot for you to go to, a coordinate and a claim, the way a partner on a fireground calls a location and a reason before anyone has decided what to do. Its native output is not a paragraph. It is a place to look.

One thing it must do, and doing it reliably is unfinished work rather than a property to claim in the present tense: say I don't know when the data where you stand does not decide the answer, instead of producing a confident guess. No machine calibrates its own uncertainty perfectly, and a partner that fakes certainty is worse than none. That is a standard the thing is built toward, not a box already ticked. What position buys it is a fighting chance: its claims are scoped to a place you can walk to and check, so when it is wrong, it is wrong somewhere specific, in front of you, where you catch it.

The boundary lives in the interaction itself. It can mark anywhere, and it can move nothing. It stops at the line where deciding begins, because the one who answers for what happens next is the one who should decide it. The point was never to route around the engineer. The engineer is the part that has to live with the call. So the deciding stays with the engineer, and the assembling, joining, holding-still, and remembering go to the machine that is good at them, and no further.

A place must tell the truth about itself

A place can lie in ways a panel cannot, and the more whole it looks, the more dangerous the lie. The honesty is not a virtue draped over the design. It is the design.

A moment reconstructed is only as complete as what was recorded. A service no one instrumented is not drawn as a gap; it is simply not there, absent from the scene as it is absent from the record, and a scene that looks complete tells the engineer's own eyes that nothing is missing. So the scene must wear its blind spots. The unobserved has to look unobserved. Inferred structure has to look inferred. A world that is live but delayed has to show its delay, because animated traffic that is really ninety seconds old is exactly the misplaced trust that gets people hurt.

And there are debts no honest rendering pays, so they are owed here, plainly:

The moving map has a price. Because the layout reflows, you cannot build the muscle memory of a room that never changes. You pay a re-orientation cost every time you look, reading the current shape instead of reaching by reflex, and you pay it per environment, since staging and prod need not settle the same way. The bet is that a shape you must re-read but can trust beats one you have memorized but cannot. That bet is not free and not yet proven.

Comparison assumes the thing you return to still exists. A service renamed, split, or retired since last Tuesday has no identity to stand beside its old self, and honest comparison has to say when it is comparing a thing to its successor rather than to itself.

Whether a scene of thousands of services stays legible instead of becoming its own noise: unproven. The intended answer is that a place is entered one neighborhood at a time, but a large enough topology change can scatter a neighborhood rather than move it, and whether the clustering keeps callers gathered around their hole at that scale has to earn itself.

How often an inferred connection is wrong, and how often a rendered absence is a false alarm: unmeasured, and it has to be measured, because a phantom that fires when nothing was lost burns trust in a week.

And the debt that outranks the rest. The number this whole idea lives or dies on is time from first anomaly to witnessed cause: the minutes between the page and the moment an engineer is looking at the reason and knows it, at lower cognitive cost, measured against the best flat baseline there is, a good trace waterfall and a well-tuned dashboard. That number does not exist yet. When it does, it should be published with the method in the open, whichever way it lands, and if it lands the wrong way, that belongs on the same page as this.

It is not the metaverse

Someone always asks, so, quickly: no NFTs, no virtual land, nothing to buy low and sell high. It runs on the screen already in front of you; a headset is the deepest way in, for anyone who wants to stand fully inside the system, never the price of admission. The consumer metaverse needed the headset because the room was empty without it, and built places hunting for a purpose. A production system is already full, already doing something every second, and only needed to be shown as the place it is.

The nearest true ancestor is the Bloomberg Terminal, and the resemblance has to be stated exactly, because the Terminal is flat, dense, and panel-driven, the very form this refuses. What is borrowed is not its rendering but its inhabitation: a professional lives in it all day, learns it, is fluent in it the way you are fluent in your own hands. That habitation is the half the incumbents never reached for, and the Terminal itself shows the persistence and the standing-in only in silhouette. This has to actually build them.

The graveyard

People have built spatial observability before, and it died. Netflix open-sourced Vizceral, a beautiful live traffic map, and let it go quiet. CodeCity rendered software as buildings. 3D topology viewers and VR network operations centers get rebuilt every hardware cycle and buried every time, and the simplest explanation is not that a paradigm suppressed them. People tried them, and users did not want them. That deserves an answer, not a step around.

The answer is a bet, not a proof. What died was spatial rendering: pretty maps you flew a camera through and then went back to your dashboard to work. By the three tests above, every one of those corpses was flat. Vizceral drew the traffic; it did not know a service as the same thing across two Tuesdays, did not scope a partner to where you stood, did not carry an investigation with you when you moved. It was a picture, not a place to work in. The graveyard is full of visualizations. What is claimed here is persistence, occupied position, and a stateful session as the substrate the work runs on. That may fail too, and if it fails the same way, it belongs in the same graveyard, and the honest thing will be to say so on the same number. But it is a different bet than the ones buried: the difference between a view you look at and a place you are in.

As for why the incumbents never grew it from the inside: what shipped, shipped as bolt-ons. A pause button, a pinned board, a saved query, each a coping mechanism rather than the thing, because a flat tool is stateless and query-shaped all the way down, in the pipeline where batching is cheap and holding a live scene is dear, in the interface where a view is drawn fresh and never inhabited. Distributed tracing is the one capability that reached first class, and tellingly it did so on its own ground rather than patched into a dashboard, and even it joins one request, not a neighborhood. That a describable, asked-for thing arrived only as patches is a hint about where it fits in the old paradigm. The graveyard is the counter-hint. Neither settles it. The number does.

Refuse the flatness

The dashboard earned its place. Under the hardware of 2005, a flat field of charts was the best a running system could be compressed into, and observability as a discipline is one of the real achievements of the era. It is not the enemy. It is the past, and it is owed credit on the way out.

You have felt the rest of this at 3 a.m., the certainty that there had to be a better way to hold a system than in your own tired head. The claim is that the better way is a place. Not a prettier picture, which has been tried and buried, but a stateful, occupied, living position you work from, the machine's context scoped to where you stand, the deciding still yours. Whether that gets an engineer to the cause faster than a good waterfall or a well-tuned dashboard is not proven. It is a bet, it is falsifiable, and the honest move is not to ask anyone to believe it. It is to name the number it turns on, run it in the open against the best flat tool there is, and publish it whichever way it lands.

Refuse the flatness if the number earns it.

That measurement is the next thing to build.

#refusetheflatness