Skip to Content

Release changes without accidental manual steps

We help organise the path from a prepared change to a verified working version. We configure reproducible deployment, checks and a clear approval process. The team knows what is being released, who authorises it and what to do if something goes wrong.

Discuss a project ↗

What your team gets

A clear version.

Everyone knows which changes will reach the working system.

Checks before release.

The new scenario is assessed in a safe environment where needed.

Control during release.

There is a process for cutover and confirmation of the result.

An error response plan.

We discuss recovery and the limits of data rollback in advance.

A release with a decision and a recovery path

From a known version to a checked release

Known version

Source and scope are identifiable.

Suitable test environment

Check the real workflow and its exceptions.

Responsible person approves

Without approval, do not release.

Deploy the agreed version

Then verify production; follow the agreed recovery plan if checks fail.

Any failed gate: stop and follow the recovery plan

A software rollback does not undo changed records or sent messages.

If a check fails, stop and follow the agreed recovery plan. Rolling back software does not automatically undo changed records or messages already sent.

When every update becomes a separate operation

Settings differ between environments, the required command is buried in a message thread, and a successful build is mistaken for a successful release. After a change it is difficult to know which version is running and which data has already been transformed.

We make steps explicit and repeatable. Automation helps execute an agreed process, but does not replace a risk decision or authorisation to change a working system.

What we organise

Release version and contents

We record the application, dependencies, configuration and data changes. Source code is kept separate from secrets and environment settings. The release has clear provenance so it can be verified and compared with the running version.

Checks before production

We select automated and manual checks for the actual risk. A test environment must not silently send real emails, change external systems or process real payments. Differences from production are documented rather than hidden.

Deployment and confirmation

We prepare the sequence, permissions and change window. We check dependencies and necessary backups. After launch we verify a selected user journey, such as creating an enquiry, opening material or passing an order.

Response to failure

We establish in advance when to stop a release, when an application rollback is possible and when data recovery is needed. A reversible version change and an irreversible data-structure change are not the same scenario.

A release record before the change

Illustrative record · not a completed client project
Change
An update to a booking workflow
Version and contents
Application image, configuration, dependencies, migration and attachments
Authorisation
Agreed responsible person, permissions and release window
Acceptance check
Check rescheduling and double bookings in the selected user journey
Stop condition
Stop on a failed check; reconcile unknown external outcomes before retrying
Recovery path
Name the responsible person and available previous version; agree how migrated data is handled and which changes cannot be rolled back.

Examples

An Odoo website change.

Seeing a new page is not enough. We check content editing, saving, neighbouring pages, required locales and a selected contact path. The current version and theme's capabilities are considered separately.

An order exchange update.

We test a repeated event, delay and lost response. A retry must not create a second order or repeat an action already performed. An unknown result is first reconciled with the external system's state.

How pNet works

Agree release boundaries.

What changes, who authorises the transition and which data may be affected.

Prepare repeatable delivery.

Versions, configuration, secrets and required dependencies are kept separate.

Test and release.

Run tests and a business scenario before cutover, then verify in the working environment.

Record the outcome.

What was released, which checks passed and what to do about remaining risk.

Limit: After launch we help maintain the process: update dependencies, refine checks and investigate failed releases. We do not build a complex delivery platform where a simple reliable process is sufficient.

Our approach →

What your team receives

A clear release scope, repeatable sequence and record of the result. The team can see which checks ran, who authorised the change and what recovery path is available. This reduces dependence on individual memory without removing human responsibility.

For a small project, a reproducible build and careful update of one application may be enough. For a container stack, pNet records the image, configuration, database migration, attachments and dependencies, separating preparation, testing and authorised release across environments. A Git commit, a new Docker version and a successful process start do not equal an accepted business change.

For example, a change to salon booking is tested against rescheduling and double bookings; a new academy registration method against allocation of places and access; a supplier catalogue against consistency of product, order and document. These examples determine release acceptance checks.

Restoring a previous image does not always undo changed data or messages already sent. Therefore, checks and recovery, data compatibility and a plan for partial outcomes are designed before launch. Kubernetes and automatic rollout remain options when a need is demonstrated, not mandatory complexity for every website.

Note: rolling back an application version does not undo sent emails, third-party payments or already changed data. These need separate rules.

Frequently asked questions

What do we agree before work starts?

Production changes, data migrations and external actions require explicit approval. Rollback feasibility and data compatibility are reviewed before release; automation does not remove these decisions.

What should I share to get started?

Describe your systems, the problem and any known constraints. You do not need a complete technical specification. Please leave passwords, keys and customer data out of your message.

Do we need a large CI/CD pipeline?

No. We start with the team's scale and risk. A versioned process, a few useful checks and explicit authorisation are often better than a complex system without an owner.

Does a successful build mean a successful release?

No. It confirms only its own stage. Deployment, application state and the working scenario are checked separately.

Can we always roll back with one button?

No. External actions and data changes may be irreversible. The return plan is defined before release and tested within the agreed scope.

Can releases continue to include manual steps?

Some actions can remain manual if they have a clear reason, instructions and confirmation. The goal is a controlled process, not automation for its own sake.

Make the next release clear

Tell us how changes are delivered today and where errors or dependence on one person arise. We will choose a first verifiable process.

Discuss a project →