The infrastructure month

There comes a point in a platform's life where the right thing to ship is nothing the user will ever see.

This was that month.

The product had grown enough by January that the parts I had been deferring stopped being acceptable to defer. The platform had real users. It had real data. It had a live session surface where multiple people now share the same campaign at the same time. The infrastructure that had been "good enough for the prototype phase" was no longer good enough, because the prototype phase had quietly ended without me sending it a goodbye note.

So I cleaned up. I locked things down. I made the system easier to understand when something went wrong, because at the scale the platform was approaching, "I will figure it out when it breaks" was no longer a strategy.

Cleaning up

The cleanup work in this stretch was less about adding new infrastructure and more about taking the infrastructure that existed and making it serious.

Some of it was reorganization. Code that had grown into one place and needed to live in another. Patterns that had been copy-pasted three times and needed to be one shared thing. Configurations that had been tuned for development and were still running in production unchanged.

Some of it was tightening. Boundaries that had been loose because they could be when the platform was small. Defaults that had been permissive because the small early audience had not made permissiveness a problem yet. The kind of work that has the same shape regardless of what platform you are building: take the things you knew you would have to do later, and do them.

None of this is interesting to describe in detail. Most of it would not even be interesting to read about line by line. The only thing worth saying is that infrastructure cleanup is not glamorous, and the platform is better for it, and that is the whole story.

Locking things down

The other half of the month was about the boundaries.

A platform that started as one user's tool and grew into a multi-user product accumulates assumptions about who can see what. Most of those assumptions are right. Some of them turn out to be loose in ways that the early product did not test. The work in this stretch was identifying which boundaries needed to be tighter and tightening them.

The honest framing is that the platform had grown out of its old security posture without anyone explicitly noticing. Live sessions made multiple users share data. Public sharing made some content reachable without authentication. Campaign participants meant the "owner" model was no longer the only model. Each of those features had been shipped with the right intent. None of them had been audited together. The cleanup pass was the audit.

I am not going to detail what changed, because the specifics are not the post. The shape is the post: the platform got better at knowing who was allowed to do what, and the system that enforces that is now stricter than it was a month earlier.

Sentry and the value of seeing

The infrastructure investment that I will name specifically is observability.

Sentry has been in the stack for a long time, but this stretch was when it got upgraded into something I actually rely on. Distributed tracing across the parts of the system that interact with each other. Metrics on the surfaces that needed to be watched. The kind of instrumentation that turns "something is slow" from a guessing game into a question with an answer.

Sentry is one of the few tools I would put on a short list of things I would defend. Building a complex system without good tracing is a job I have done before and do not want to do again. The platform had reached a complexity where errors started to have multiple plausible causes, and the only way to debug efficiently was to be able to follow a request through the system end to end. That capability was the thing I most wanted to have before the next big feature stretch, and it is the thing I am most relieved to have now.

What the month shipped

A platform that is cleaner than it was a month earlier. Boundaries that are tighter than they were. Observability that is sharper than it was. Nothing a user can point at, but a system that is better at being a system.

The next stretch is back to features. The cleanup made sure the next stretch will not be sitting on top of work I knew was wrong and was hoping nobody would notice.