Improve the whole path
Delivery time is often lost between the steps people notice. A change waits for a reviewer, a pipeline waits for a runner, a developer repeats information in another tool, or a release waits for someone who didn't know it was ready. Making one job faster doesn't help if the delay moves to the next handoff.
People can move work forward more easily when they know who's responsible for the next step and receive feedback in time to act on it. But a change that helps one person may make work harder for someone else. Batching reviews, for example, may suit a reviewer's schedule while leaving authors waiting and forcing them to rebuild context later. Looking at the path from request to production helps you see whether an improvement saves effort overall or shifts it to another person.
GitLab can show parts of this path. Value Stream Analytics measures the time between supported issue and merge request events, and CI/CD records show queue, job, and deployment activity. Those records say when something happened. They don't say whether the time went into delivering a change, applying a necessary control, or waiting unnecessarily. Value Stream Analytics also includes an item in a stage only after it reaches that stage's end event, so unfinished and abandoned work can be absent from the result.
A slow step can have several causes. A pipeline may be waiting for a runner, running long tests, repeating work, or recovering from unreliable jobs. A review may be waiting for an owner, working through a large change, or completing a specialist risk check. Following a real change helps you tell these situations apart, so the next rule, tool, or automation addresses the cause of the delay.
Learn from a real change
If a one-line change had to reach production, what path would it follow and how long would it take? A recent change in an ordinary project gives you a way to compare the answer with what happened. Small changes make handoffs and waits easier to see because the implementation itself is unlikely to explain most of the elapsed time.
The history may be spread across a request or issue, commits, a merge request, review, pipelines, a production deployment, and an incident or follow-up issue. Putting those records together can reveal gaps that aren't obvious in any one view. The questions behind those gaps often concern:
- who knew the work was ready;
- whether somebody was working or waiting;
- what caused a retry or return to an earlier step;
- where ownership or tools changed;
- what is recorded in GitLab and what happens elsewhere.
The people doing the work may describe a different process from the one in the written instructions or GitLab records. Open questions about a recent change give people room to explain what happened, and several perspectives can help fill in the gaps. Developers may speak more freely in a separate conversation when roles or group dynamics make it difficult to raise a concern. A disagreement is worth keeping in the notes without immediately deciding who's right: it may reveal a manual step, a local workaround, or a difference between the stated process and daily work.
Once you understand how the work moves, it's easier to choose Value Stream Analytics stages that reflect it. Each stage measures the time between a supported start and end event. Those events need to match the transition you want to understand; a convenient timestamp may describe something else. Where GitLab doesn't record part of the path, another source can fill in the picture, or you can improve how that transition is recorded before measuring it as a stage.
A delay that's repeated, unpredictable, or costly is a place to look for an improvement. Its size tells you how much it matters; its cause helps you decide what to change. Correcting runner configuration might be a focused task, while unclear review ownership calls for agreement about who responds and when. Automating the current routing won't resolve that uncertainty.
A trial in a project that follows the normal delivery path lets you find out whether the proposed change helps. A record of the starting point and expected result gives the team something to compare, while quality and stability checks help reveal unwanted effects. An owner, an agreed review date, and a way to undo the change make it easier to follow through on what you learn.
At that review, developers' experience matters alongside the numbers: did the work become easier across the whole path? The answer may support keeping the change, adjusting it, stopping it, or trying it more widely. If it helps, similar projects are a natural next step. Reviewing each group before adding more projects gives you a chance to carry the lessons forward.
Keep necessary controls and unfinished work visible
The Value Stream Analytics event model sets the limits of a stage. Default stages depend on links among issues, commits, merge requests, pipelines, and production deployments. Custom stages let you choose different supported event pairs.1 If a team deploys outside GitLab or manages part of the work in another system, the GitLab view can cover only the events it receives.
The typical duration doesn't tell you what happened to the slowest changes. A median can hide a few very long waits, and work that hasn't reached the end event won't appear in that stage's duration at all. The individual items give you more context, especially those that are blocked, abandoned, reopened, or unusually old. Differences in work type, release cadence, staffing, or incident load can also explain why two periods look different.
Some delay protects the product. A specialist review, controlled release, or manual decision may be appropriate for high-risk work. The opportunity may be to make that wait more predictable rather than remove the control. Quality, security, stability, and developer experience help you judge whether a faster path is also a better one.
Comparing teams makes sense only when the comparison can answer a shared question and the records describe similar work in the same way. A mobile release, a continuously delivered service, and a library publication may need separate views. These measures help teams understand and improve how work gets done; they aren't a basis for ranking individual developers.
Questions to ask
- What path does a small, normal change follow from request to production?
- Where did a recent change wait, repeat work, or change owners?
- How did the next person know the work was ready?
- Is a pipeline delay caused by queueing, execution, repeated work, or retries?
- Is a review delay caused by ownership, change size, reviewer capacity, or a needed control?
- Which work is missing because it never reached the selected end event?
- Where do the GitLab records, written process, and developer account disagree?
- Which delay is repeated or unpredictable enough to address now?
- What would show that the trial helped without moving risk elsewhere?
- Which projects are similar enough for the next rollout wave?
Further Reading
Notes
-
Custom value-stream stages are available in Premium and Ultimate. Free provides project-level default stages. Understanding where work waits doesn't depend on a custom dashboard; conversations and a sample of recent changes can help identify delays too. ↩
- Value stream analytics defines the supported event pairs, stage calculations, completed-item behavior, feature availability, and processing delay.
- A value-stream improvement cycle walks through tracing a change, choosing a bottleneck, testing an improvement, and deciding whether to expand it.