Risky releases

Every release breaks something

A release is followed by a regression, and to be safe a manual check is added before the next one. The next release goes out later, carries more changes, is riskier and breaks more. Behind this are releases that are too big, tests missing where they matter, environments that differ from each other and an architecture that forces teams to release together.

Book a call

Does this sound familiar?

  • Every release is followed by a few regressions, and each fix risks breaking something else.
  • Nobody releases on a Friday, and before long not on a Thursday either.
  • A release follows a checklist and needs the one person who knows how to do it.
  • Everything works in staging, then the problem shows up in production and a user reports it.
  • To release, several teams have to stop work and wait for a code freeze.

How do you end up with releases that break production?

With no tests, mismatched environments and a system that can only be released whole, every release swells with changes. That is why release size is the most visible cause, and why you reduce it by working on the others.

  1. Every release carries too many changes at once

    Weeks of work go out at the same moment, so when something breaks it is hard to tell which change did it. Releasing often, in small pieces, lowers both the risk of each release and the time it takes to find the fault.

  2. Few automated tests, and in the wrong places

    When safety comes from a manual check, each release costs days, so people release as rarely as they can. You need automated tests on the parts that matter, written together with the code, so the team can trust what it releases.

  3. Environments that don’t match and monitoring that can’t see

    If staging and production are configured by hand and differently, some problems only appear in production. Without monitoring that flags them straight away, users find them first.

  4. Every team has to release together

    A system that can’t be released in parts forces several teams to coordinate, stop work and squeeze everyone’s changes into one event. The remedy lies in the architecture, with boundaries that let each team release its own part.

What changes when releasing stops being frightening

Releasing becomes an ordinary operation. It runs from the pipeline, and anyone on the team can trigger it. Changes go out small and often, and when something goes wrong you roll back quickly and know where to look.

Friday releases are like any other day, and finished work reaches users as soon as it’s ready. The team spends its hours on features, and urgent fixes become rare.

How did your last release go?

We go back over your last release that went wrong, from the first change to the fix. Retracing it shows whether the work to do is in the pipeline or in the tests.

We use your data to respond to your request. Read our Privacy Policy.