Before releasing an Azure DevOps build, verify that the previous application can still read and write the data the new version will create. Keep the exact deployable artefact, rehearse the return in a test environment, and define who can authorize it. A successful build, an available backup and a green connectivity check answer different questions; none alone proves that an order or service request will remain usable after a rollback.
This practical guide focuses on a small business application: release preparation, Azure Pipelines controls, data compatibility and evidence after recovery. The example below is fictional and was tested locally with Python and SQLite only.
When a passing pipeline leaves an unanswered question
The gap often appears when the pipeline builds and tests the new code, but nobody has tried the old code against data written by the new release. Other warning signs include an overwritten container tag, a missing previous package, an undocumented database migration or a recovery procedure that ends at “restart the service”. These are reasons to investigate, not evidence of a production outage.
Choose one critical workflow as your acceptance test: create a test order, reopen it and verify its saved amount and status. A health model should connect technical components to user outcomes. Microsoft’s workload health guidance explains that relationship.
Prepare the access, environment and recovery record
You need access to the Azure DevOps project, its pipeline and deployment environment, a retained previous artefact, the database migration history, runtime configuration references and relevant application logs. Assign a release owner and an incident decision-maker. Use synthetic records in an isolated test environment; keep customer data and secrets out of the exercise. Disable real notifications and use external services’ test modes so a test order cannot trigger a customer invoice or message.
Budget for engineering time, a representative test environment, build capacity, monitoring and any applicable storage or registry charges. The actual cost depends on your setup and retention needs; this guide does not assume a free tier or quote a service price.
Build, test and publish one identifiable artefact
Keep the CI sequence explicit: restore locked dependencies, build the application, run the relevant tests and publish the resulting package. Record the source commit, pipeline run, artefact identifier and integrity evidence. Deployment should retrieve the selected package, rather than rebuild an old commit during an incident.
Promote the same tested artefact between environments. Supply environment-specific endpoints and secret references through runtime configuration. Record configuration changes separately, because an older application may require different keys or settings.
Azure Pipelines supports publishing and downloading artefacts from identified runs. Deleting a run also deletes its associated artefacts, so confirm that the previous package survives your retention policy and is actually downloadable. Microsoft documents these artefact operations and the deletion behaviour.
For containers, record the digest
If the application uses Docker, retain the image and record its digest in the release record. A tag such as latest can point to different content later. Pulling by digest selects the referenced image content; it does not establish database compatibility. Pinning also means that adopting a security update requires deliberately selecting an updated image. See Docker’s image-pinning guidance and pulling by digest.
Put approval on the deployment resource
Connect the deployment job to the intended Azure Pipelines environment and have its owner configure the required approval or checks. These controls belong to the resource and are managed through the Azure Pipelines interface, rather than defined in the pipeline YAML. Verify the approver and the environment the stage actually consumes. Microsoft explains resource approvals and checks.
A deployment job’s on: failure hook is a place for recovery steps your team supplies. It is not an automatic database restoration or a tested rollback procedure. Define which steps are permitted, their prerequisites and the evidence they must return. Deployment-job lifecycle hooks are documented here.
Check both the schema and the values
During a release where versions can coexist, prefer compatible additions and retain structures the previous version uses. Microsoft recommends schemas that support both versions during canary deployment. Keeping those structures throughout your chosen rollback window is an engineering recommendation, whose duration depends on your application. See Microsoft’s modernization guidance on data consistency.
A nullable column can be compatible with old code that selects its columns explicitly. That does not make every additive migration safe: constraints, defaults and changed meanings matter too. An unfamiliar status value can break the previous application even when every expected column still exists. Test new writes through the old application, then test writes made after returning to it.
A local example: two orders remain readable
Illustrative exercise, executed November 6, 2026: we ran nine checks using local Python files and SQLite, with fictional order amounts represented as integer cents. Version 1.0.0 read one order. Version 1.1.0 added an optional note column and a second order. We then ran the retained 1.0.0 file against the same database, without restoring a backup.
| Point in the exercise | Application | Orders read | Total in cents |
|---|---|---|---|
| Before the change | 1.0.0 | 1 | 12,500 |
| After the compatible change and new write | 1.1.0 | 2 | 17,499 |
| After returning to the retained file | 1.0.0 | 2 | 17,499 |
The two orders totalled 17,499 cents, or a fictional CAD 174.99, after the return. A separate write through version 1.0.0 then created a third order, which version 1.1.0 could read.
All nine checks passed, including checks that expected a refusal or error. Changed file bytes were rejected; a renamed column blocked the structural check; and an unsupported status failed the business read despite a matching schema. On those incompatible copies, a simple SELECT 1 connectivity probe still succeeded. Reading an older backup separately showed that it lacked later orders.
This tested the fixture’s behaviour only. No Azure pipeline, Docker image, HTTP endpoint, production deployment, concurrent writes or external integration was exercised. The file’s SHA-256 identified that Python file; it was not a container digest or a complete application integrity assessment.
Use logs to decide, then verify the workflow
- Stop further rollout and identify the release, time window and affected operation from logs and error records.
- Check which schema, data, configuration and external operations changed.
- Confirm that the retained application accepts the current state. If it does not, assess a controlled corrective release instead.
- Obtain the required authorization and execute the tested recovery procedure.
- Verify the deployed version, repeat the critical workflow, inspect its saved result and review fresh logs.
Microsoft’s safe-deployment guidance recommends halting a problematic rollout and choosing recovery according to the workload. Record the observed outcome; a successful restart is only one part of that evidence.
Know what an application rollback cannot reverse
Returning to old code does not undo a sent notification, completed payment or external update. Restoring a database snapshot is a separate operation that can omit subsequent writes. Destructive migrations and incompatible values need a specific recovery plan; do not apply an inverse migration blindly. Queue replay, uploaded files, caches and concurrent activity also need their own checks.
Checklist before release
- Previous artefact retained and retrievable.
- Runtime configuration and release identifiers recorded.
- Old and new versions tested against new data.
- Approval attached to the intended deployment resource.
- Incident owner, logs and recovery procedure ready.
- Business workflow and persisted result checked after recovery.
Make the release procedure fit your application
If an application or integration has outgrown its release process, discuss your application with Hamdi Services. Bring the current pipeline, migration history and the workflow that must remain usable.

