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.

Map of a workspace with a feature track and a hotfix trackThe 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. A guard sits on every step inside a track. Both tracks feed one release line: Stage, then Prod, with a guard on the step between them. Dashed arrows show each release that reaches Prod being synced into the build and test environments of the tracks.Feature trackHotfix trackRelease lineSync from ProdSync from ProdDev 02BuildTest 02TestDev 01Build, mirrors ProdTest 01TestStageRelease candidateProdShips by releaseMap of a workspace with a feature track and a hotfix trackThe 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. A guard sits on every step inside a track. Both tracks feed one release line: Stage, then Prod, with a guard on the step between them. Dashed arrows show each release that reaches Prod being synced into the build and test environments of the tracks.Feature trackHotfix trackRelease lineDev 02BuildTest 02TestDev 01Build, mirrors ProdTest 01TestStageRelease candidateProdShips by release
  • 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.
Solid arrows deploy a change. Dashed arrows sync a release from Prod into a track it did not come from. A workspace can have any number of tracks.
  • 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.

  1. Inside a track

    Test 02 receives CHG-1002 as soon as it is ready, whatever else is in progress.

  2. At Stage

    Changes from every track meet here. Stage holds what is in Prod plus the release candidate, and Lanestep shows the difference.

  3. 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.

A sync from Prod into Dev 02 with one clashRelease REL-1005, which shipped the hotfix CHG-1003, syncs from Prod into Dev 02 as the unmanaged solution of exactly what reached Prod. Before the import, Lanestep finds that the web resource common.js changed in Dev 02 since the last sync, through the work of CHG-1002. The team chooses between two decisions: take the change, so Dev 02 receives the version in Prod, or keep the work and merge the fix by hand. They keep the work, so CHG-1002 needs a rebuild.ProdREL-1005, CHG-1003Unmanaged solution from ProdDev 02Feature track buildClash check1 component clashesfops_/scripts/common.jsClashChanged in Dev 02 by CHG-1002 since the last sync.DecisionTake the changeDev 02 receives the version in Prod.Keep the workMerge the fix by hand in Dev 02.Needs rebuild

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.

The guards Lanestep runs before Prod, what each one catches, how to clear it, and whether a finding can pass with a reason
GuardWhat it catchesHow to clear itCan pass with a reason
Not readyA change has not finished every step of its track.Finish the track. No
Newer version in ProdProd already holds a newer version of a solution in the release.Rebuild the change, so its export gets a higher version. No
Older copyA 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
RetestAnother 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 changeAnother 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 ProdAn 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
ApprovalsThe release does not have the approvals its policy requires, or someone rejected it.Get approvals from people who built none of its changes. No
FreezeA 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 reason
  • Newer 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 reason
  • 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.

    How to clear it: Rebuild the change after the sync.

    Can pass with a reason where policy allows
  • Retest

    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 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.

    How to clear it: Add that change to the release.

    Can pass with a reason 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.

    How to clear it: Remove the unmanaged layer in Prod.

    Can pass with a reason where policy allows
  • Approvals

    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 reason
  • Freeze

    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.

A hotfix takes a booked Stage, in six stepsStage is booked by REL-1004, the release of the feature CHG-1002. Step 1: the hotfix CHG-1003 takes Stage, and CHG-1002 needs a retest. Step 2: CHG-1003 ships to Prod. Step 3: the sync into the feature track finds a clash on common.js, and the team keeps its work. Step 4: the older copy guard blocks CHG-1002. Step 5: CHG-1002 is rebuilt and reaches Stage again. Step 6: CHG-1002 ships to Prod, the booking ends, and the release syncs into the hotfix track.Feature trackCHG-1002Hotfix trackCHG-1003StageProd123456Stage booked by REL-1004Needs retestTo StageTook StageCHG-1003 in ProdKept the workOlder copyRebuiltBack at StageCHG-1002 in ProdSynced
  1. 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.

  2. Step 2: The hotfix ships

    CHG-1003 goes to Prod in a release of its own.

  3. 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.

  4. 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.

  5. Step 5: The feature is rebuilt

    The new export of CHG-1002 includes both changes. It passes Test 02, reaches Stage again and ships.

  6. 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.