How it works
How a change reaches Prod
Each change moves along its track, one checked step at a time. This page follows that path in an example workspace with a feature track and a hotfix track.
Two tracks, one release line
The map shows each environment once. The feature track builds in Dev 02 and tests in Test 02. The hotfix track builds in Dev 01, which mirrors Prod, and tests in Test 01. Both tracks feed the release line: one Stage and one Prod. When a release reaches Prod, Lanestep syncs it into the other track.
- Deploy
- Sync from Prod
- Guard
- Feature track
- Dev 02 to Test 02. Changes are built in Dev 02 and tested in Test 02. Within the track, each change moves on without waiting for other work.
- Hotfix track
- Dev 01 to Test 01. Changes are built in Dev 01, which mirrors Prod, and tested in Test 01. A hotfix can take Stage even when a release has booked it.
- Release line
- Stage to Prod. Stage, then Prod, shared by every track. Changes from all tracks meet at Stage. Prod receives them only in a release, after the guards run.
- Sync from Prod
- Prod to every other track. When a release reaches Prod, Lanestep syncs it into every track it did not come from. Each clash it finds needs a decision first.
Build environments
Makers build here, and Lanestep exports each change from here. In a sync, a build environment receives the unmanaged solution of exactly what reached Prod.
Test environments
A change is tested here before it joins the release line. Test environments receive managed solutions only.
Stage and Prod
The release line that every track shares. Both receive managed solutions, and Prod receives them only in a release.
Each change moves on its own
A change holds what one work item changed. Within its track, it moves to the next environment without waiting for other work.
Inside a track
Test 02 receives CHG-1002 as soon as it is ready, whatever else is in progress.
At Stage
Changes from every track meet here. Stage holds what is in Prod plus the release candidate, and Lanestep shows the difference.
To Prod
The release manager picks which changes go. Prod receives them in the order Stage did, so Prod gets what Stage tested.
The sync
When a release reaches Prod, Lanestep syncs it into every track it did not come from.
The build environment receives the unmanaged solution, then the test environments receive the managed one. Both hold exactly what reached Prod. Before the import into the build environment, Lanestep checks it for work on the same components. A component changed in both places is a clash, and each clash needs one of two decisions:
- Take the change
- The environment receives the version that is in Prod, in place of its own work.
- Keep the work
- The environment keeps its own work, and someone merges the fix by hand. The change that owns the work is marked Needs rebuild, so its next export includes the fix.
The import waits until each clash has a decision. Each environment shows how many releases it has not received yet.
The guards
A guard is an automatic check. Before a release goes to Prod, Lanestep runs every guard, and each finding shows what the guard caught and how to clear it. Lanestep also flags two changes in progress that share a component.
| Guard | What it catches | How to clear it | Can pass with a reason |
|---|---|---|---|
| Not ready | A change has not finished every step of its track. | Finish the track. | No |
| Newer version in Prod | Prod already holds a newer version of a solution in the release. | Rebuild the change, so its export gets a higher version. | No |
| Older copy | A change holds a copy of a component that is older than a change already in Prod. Shipping it would undo that change. | Rebuild the change after the sync. | Where policy allows |
| Retest | Another change replaced a shared component in Stage after this change was tested there. | Test it again in Stage and mark it retested. | Where policy allows |
| Work of another change | Another change from the same build environment shares a component but is not in the release. Its work may ship along with this one. | Add that change to the release. | Where policy allows |
| Unmanaged layer in Prod | An unmanaged customization in Prod sits on top of a component, so the release would not take effect. | Remove the unmanaged layer in Prod. | Where policy allows |
| Approvals | The release does not have the approvals its policy requires, or someone rejected it. | Get approvals from people who built none of its changes. | No |
| Freeze | A freeze stops deployments to Prod. | Wait for the freeze to end. | Where policy allows |
Not ready
A change has not finished every step of its track.
How to clear it: Finish the track.
Cannot pass with a reasonNewer version in Prod
Prod already holds a newer version of a solution in the release.
How to clear it: Rebuild the change, so its export gets a higher version.
Cannot pass with a reasonOlder copy
A change holds a copy of a component that is older than a change already in Prod. Shipping it would undo that change.
How to clear it: Rebuild the change after the sync.
Can pass with a reason where policy allowsRetest
Another change replaced a shared component in Stage after this change was tested there.
How to clear it: Test it again in Stage and mark it retested.
Can pass with a reason where policy allowsWork of another change
Another change from the same build environment shares a component but is not in the release. Its work may ship along with this one.
How to clear it: Add that change to the release.
Can pass with a reason where policy allowsUnmanaged layer in Prod
An unmanaged customization in Prod sits on top of a component, so the release would not take effect.
How to clear it: Remove the unmanaged layer in Prod.
Can pass with a reason where policy allowsApprovals
The release does not have the approvals its policy requires, or someone rejected it.
How to clear it: Get approvals from people who built none of its changes.
Cannot pass with a reasonFreeze
A freeze stops deployments to Prod.
How to clear it: Wait for the freeze to end.
Can pass with a reason where policy allows
Only people in roles the policy names can pass a finding. Each pass records the person, the time and the reason. When the deployment to Prod starts, the release keeps every finding and pass as they stood at that moment.
A hotfix takes a booked Stage
A release can book Stage to keep changes from other releases out. The hotfix rule lets a hotfix take Stage anyway, and Lanestep handles what follows. In this example, CHG-1002 on the feature track and CHG-1003 on the hotfix track both change the web resource common.js.
Step 1: The hotfix takes Stage
CHG-1003 takes the booked Stage under the hotfix rule, and the release that booked Stage records it. CHG-1002 was already tested in Stage, so it is marked Needs retest.
Step 2: The hotfix ships
CHG-1003 goes to Prod in a release of its own.
Step 3: The sync finds the clash
The sync into Dev 02 finds that CHG-1002 also changed common.js there. The team keeps its work and merges the fix by hand.
Step 4: The guard holds the feature
CHG-1002 now needs a rebuild, because its copy of common.js is older than the hotfix. Shipping it as it is would undo CHG-1003 in Prod, so the older copy guard holds it.
Step 5: The feature is rebuilt
The new export of CHG-1002 includes both changes. It passes Test 02, reaches Stage again and ships.
Step 6: Every environment is up to date
The release of CHG-1002 syncs into Dev 01 and Test 01, and the Stage booking ends. Every environment now has every release.
When a release goes wrong
Dataverse does not roll back cleanly. Uninstalling a solution exposes the layer beneath it, and deleting a table deletes its data. Lanestep says plainly what it can and cannot undo.
Compensating releases
A compensating release is a new release that undoes an earlier one. It restores the earlier version of each component that release changed, where Dataverse allows, taken from the record. A component the release created stays, and you can hide it from apps or switch it off with an environment variable. Lanestep says what stays, and why.
Rebuild
A change marked Needs rebuild goes back to the start of its track. Its next export includes the fixes that reached Prod, and it passes its test environments again before it returns to Stage.
See your own tracks in Lanestep
Book a demo to walk through your environments, tracks and change board with the team building Lanestep.