Back to Thoughts

The Boring Infrastructure Behind Shipping Weekly

Jan 27, 20265 min readView raw

We ship weekly at DevDash Labs because we removed the friction that usually turns small changes into release drama.

The work is not glamorous. Typed API contracts, staging environments, feature flags, lint rules, and ADRs do not make a good launch tweet. They do make it much harder for a normal Tuesday deploy to turn into a production incident.

Link to this sectionWeekly shipping breaks when coordination is manual

Most teams do not slow down because engineers forget how to code.

They slow down because every change creates coordination work:

  • Backend changes an API and frontend finds out after merge.
  • Auth works locally but fails in staging.
  • Deploys take long enough that people batch risky changes together.
  • Nobody remembers why a decision was made three months later.
  • Code review burns time on formatting instead of behavior.

None of these problems are interesting by themselves. That is why they stick around.

We fixed them as infrastructure, not as recurring meetings.

Link to this sectionTyped API contracts turn backend drift into frontend errors

Our backend runs FastAPI. Our frontend runs Next.js. The boundary between them is where a lot of product teams bleed time.

FastAPI already produces an OpenAPI schema. We use openapi-ts to generate TypeScript types and API clients from that schema.

That gives us a useful failure mode: when the backend contract changes, the frontend sees TypeScript errors instead of surprise runtime behavior.

It also helps AI coding tools. Cursor and Claude Code are much less likely to invent API shapes when the generated client already encodes the real contract.

The trade-off is that schema quality matters. If the backend response model is vague, the generated frontend type will be vague too. Codegen does not fix a sloppy contract. It makes the sloppiness visible.

Link to this sectionStaging catches the bugs local development hides

Every feature goes to staging before production.

That sounds basic because it is basic. It still catches failures that local development does not:

  • onboarding flows broken by auth redirects
  • OAuth provider misconfiguration
  • missing environment variables
  • AI agent failures from rate limits or missing context
  • background jobs that work locally but fail under deployed permissions

The point is not that staging is perfect. It is that staging exercises the deployed shape of the app: real domains, real callbacks, real environment variables, real infrastructure boundaries.

Local checks prove the code can run. Staging proves the system can run.

Link to this sectionFeature flags make releases reversible

AWS Amplify deploys take about 10 minutes in our setup. Feature flags take seconds.

We use PostHog boolean flags to ship code dark, expose it to the right users, and turn it off quickly if behavior is wrong.

That changes the release model. Shipping code and releasing a feature become separate actions. The code can be deployed before the business or UX decision is final.

The trade-off is operational discipline. A flag is not free. Someone has to name it clearly, remove it when it is no longer needed, and avoid creating a graveyard of permanent conditionals.

Link to this sectionLinting and formatting remove low-value review work

Code review should be about behavior, not indentation.

On the backend, we use:

  • ruff for linting and formatting
  • uv for package management
  • pre-commit hooks for basic enforcement

On the frontend, we use:

  • eslint with strict project rules
  • prettier for formatting
  • husky for pre-commit checks
  • tsc for type checking

The value is not aesthetic consistency. The value is attention. Every comment about formatting is a comment not spent on data flow, security, failure handling, or user impact.

Link to this sectionSpecs and ADRs preserve the reason behind the code

Before we build meaningful features, we write the decision down.

We use:

  • PRDs for what we are building and why
  • specs for how the feature should behave
  • ADRs for what we chose, what we rejected, and why

These docs have a second use now: they are context for AI tools.

When Claude Code or Cursor can read the spec, the implementation starts closer to the intended design. When a human reviews the patch, they can compare the diff against the stated goal instead of reconstructing intent from scattered messages.

Six months later, the ADR matters even more. It prevents archaeology. You can see the assumptions that shaped the system, including the ones that may no longer be true.

Link to this sectionWhat we intentionally do not automate

We do not automate away manual code review.

AI writes useful code. It also makes confident mistakes. The more powerful the tool, the more important the review gate becomes.

We also do not chase 100% test coverage. We test critical paths, contract boundaries, migrations, billing flows, auth flows, and the places where failures are expensive. Full coverage can be useful in some systems, but in a young product it can also create hundreds of brittle tests that slow down every refactor.

The principle is simple: automate repeatable friction, keep human judgment where the cost of being wrong is high.

Link to this sectionThe result is fewer dramatic releases

This infrastructure gives us:

  • weekly deploys, sometimes more
  • backend contract changes that surface during development
  • fewer style debates in review
  • bugs caught in staging instead of by users
  • faster onboarding because decisions are written down
  • more time spent on product work and less time reconstructing context

None of this is revolutionary. That is the point.

Fast teams do not only move faster because they work harder. They move faster because their systems make the boring failures harder to repeat.

Keep reading

All thoughts
Gopal Khadka