Broken releases repaired, not just reverted

Going back to the previous version is half the story. The fix follows, arriving in your repository as a change your team can read, and a working release goes out after it. Nobody has to file a ticket.

A timeline of one release in four steps: it misbehaves, your users are back on the version before ("Going back: half the story"), a fix arrives in your repository, and a working release goes out ("The other half: the repair"). A note reads "Nobody had to file a ticket".
  • A release that misbehaves is not just undone. Your users get the version that worked.
  • The fix follows as a change in your own repository, then a working release.
  • Nobody on your side has to file a ticket to make that happen.

A release that misbehaves is not just undone. Your users get the version that worked, and then the fix follows: a change in your own repository, then a working release with it. Nobody has to file a ticket to make that happen.

What you get

The broken release gets repaired, not parked.

Going back to the previous version protects your users, and it is described on its own page, releases that put themselves back. This page is about what comes after. Undoing a release solves the next hour. It does not solve the next week, because the change you wanted is still not live, and someone still has to pick it up.

Here the work does not stop. Three things are different for you.

The fix comes to you. Nobody on your side has to report the fault, describe it or argue about priority. A correction arrives in your code repository, readable like any other change.

The feature still ships. The change you asked for was worth making. After the repair it goes out again, in a release that works, so the plan you agreed on keeps its shape.

Your team keeps its week. Developers are not pulled off what they were doing to chase a fault from yesterday. They can read the repair when it suits them and carry on with the work you set.

The work lands in your own code repository. That holds for repairs as much as for everything else: the fix is yours, with its explanation, and stays yours.

What it does not do

This is not a promise that nothing will ever go wrong. Releases still misbehave sometimes; what changes is how long they stay a problem and who has to carry it. It also does not turn back changes to stored data.

What it looks like in practice

Say a release goes out on a Tuesday afternoon with a new way to filter search results. Something in it misbehaves.

With a repair, the next thing your team sees is a change in the repository that corrects the fault, with a short note on what was wrong. After it comes a release that works, and the new filter is live. Your product manager hears about it as a finished item, not as an open incident they have to chase.

This is not a feature we only describe. It runs on our own product, at volume. ClickDeeper (our own product): ClickDeeper shipped more than a thousand releases in three months. At that pace, a release that goes wrong has to be repaired as a matter of course, or the product would spend its days stuck on old versions.

How we do the work stays confidential, as your work with us does. What stays visible to you is every change, the fix included, in a repository you own.

If you would like to see it for your product, we can start with one small piece of work and you can judge it by what arrives.

Proof

Products we run

When a release misbehaves after it goes out, users get the previous version back.

ClickDeeper (our own product)

ClickDeeper shipped more than a thousand releases in three months.

Drag a right triangle to see squares grow on each side. Read its story

Questions leaders ask

Do we have to report the broken release before anything happens?

No. That is the point of this ability. Nobody on your side has to notice the fault, write it up or decide who owns it.

Can our developers see what the fix changed?

Yes. The fix arrives in your own code repository like any other change, with a plain explanation of what it corrects. Your team can read it, question it, and learn from it. Nothing about the repair is hidden from the people who own the code.

What if the first fix does not hold?

Then your users still have the version that worked, because going back stays in place underneath. A repair that does not hold is not a new emergency. It is another change to get right, with the same protection around it.

What happens if we stop working with you?

Repairs belong to active work, so they stop when the work stops. Every fix made until then is already in your repository, and your users keep the last version that worked. Nothing you gained depends on us carrying on.

Lift your eyes and let us carry the rest.

Talk to us and see what carrying your product forward looks like.

Book a conversation

Prefer to write directly? contact@zefana.com