Building Durable Software Platforms

A durable platform is one you can still change three years in. That is not a function of the framework you pick — it is a function of the seams you leave. Good platforms are mostly seams: boundaries between modules wide enough to reason about each side independently.

Instrumentation from day one

The first feature we ship on any new platform is not a user feature. It is structured logging, metrics, and a trace header that flows through every request. Everything built after that is measurable by default.

// a request handler that is observable by construction
app.post('/runs', async (req, res) => {
  const span = tracer.startSpan('runs.create', { traceId: req.traceId });
  try {
    const run = await runs.create(req.body, { span });
    metrics.inc('runs.created', { status: run.status });
    res.json(run);
  } catch (err) {
    span.setError(err);
    metrics.inc('runs.failed', { reason: err.code });
    res.status(500).json({ error: err.code });
  } finally {
    span.end();
  }
});

APIs as contracts

Every public endpoint is a contract: a documented schema, a version, and a deprecation policy. The schema lives in the repo, generates client types, and is enforced at the boundary. If the server and the client disagree, the build fails — not the production request.

A platform you cannot change is a platform you will eventually abandon. Leave the seams.— Systems Group

Durability is boring on purpose. No clever tricks, no tight coupling, no optimizations that trade tomorrow for today. The reward is a system that is still a pleasure to work on years later — and a team that is not afraid to touch it.