Delivery can feel slow even when each team is busy. Work may wait for review, a runner, an environment, an approval, or another team. Pipelines may give late or unreliable feedback. Before adding automation, follow a recent change and find out where the time actually goes.
Combine GitLab records, the written process, and the experience of the people doing the work. When they disagree, the difference may reveal a hidden handoff or a workaround. Choose one delay to address, try a change, and check whether the whole delivery path became easier—not just whether one chart improved.
Choose work you can trace
Choose an owner who can bring the findings back to the team. Ask developers, someone who understands the CI/CD configuration, and the people responsible for relevant review, security, release, and operations steps to help explain the path. Agree on the desired business or user result before selecting a metric.
Choose a period with enough recent, completed work to inspect. You need access to relevant issues, merge requests, pipelines, and deployments. If work begins or ends outside GitLab, identify the other record rather than treating the GitLab history as complete.
Value Stream Analytics can help you follow stages of the work.1 Start by understanding the actual path, then choose events that represent it. You can also build the first timeline directly from issues, merge requests, jobs, and deployment records.
A worksheet can help compare several changes without losing the details. Use one row for each stage of a sampled work item, drawing on the following information:
| Field | What to record |
|---|---|
| Work item | Issue, merge request, pipeline, and deployment links |
| Context | Work type, branch model, controls, release method, and deployment target |
| Stage | The step in the team's actual workflow |
| Start and end | Event, timestamp, and source for each |
| Time | GitLab duration and a duration checked from the source records |
| Work or wait | Whether someone was working or the item was waiting |
| Handoff | Team or role receiving the work |
| Notes | Missing records, retries, blocked time, rework, or an unusual case |
Trace one normal change
Begin with a small change: if one line of code needed to reach production, what process would it follow and how long would it take? Write the expected path without correcting it during the conversation. Select a recent change and build the actual timeline beside it.
Depending on the workflow, record the request, first commit, merge request, review, pipeline queue and run, merge, production deployment, verification, rollback, and follow-up. At each gap, ask whether somebody was working, the item was waiting, or the next owner didn't know it was ready. Note handoffs and tool changes.
Record the project conditions that can affect the result: release and branch models, review and compliance checks, runner type, deployment target, shared CI/CD components, and work performed outside GitLab. Compare application and infrastructure records. A long test job needs a different response from a short job that spends most of its time waiting for a runner.
Check the times against the records
Compare the actual path with a small set of Value Stream Analytics stages. Choose supported start and end events that represent the transitions the team cares about. Create a stage only when the timestamps represent a real transition, not merely because two convenient events exist. GitLab documents the available stage events and how their durations are calculated.
Open several items included in each stage and copy their event times into the worksheet. Calculate the duration from the source records and compare it with GitLab. List expected work that is missing. GitLab includes an item in stage metrics only after it reaches the selected end event, so blocked, abandoned, or still-open work may be absent. Review those items separately and confirm the current stage-time and completed-item behavior in GitLab Docs.
Ask the people doing and supporting the work
Use open questions about recent examples: Where did you wait? How did you know the next step was ready? Which feedback arrived late? Which failures were unrelated to the change? Which approval managed a real risk? Which workaround would a new developer not know?
A joint discussion can work when participants are comfortable challenging the written process and one another's assumptions. Talk with developers separately when hierarchy, ownership, or group dynamics may filter their answers, and seek the views of platform and policy owners too. Compare their accounts with the source records. Record disagreements without judgment and ask follow-up questions; a difference often points to a hidden handoff or unclear ownership.
Keep the review practical: How long does it take to get an answer? What manual work creates frustration? How much time can teams commit to an improvement? Which result does the business need, and what constraint can't change?
Choose one delay to address
Review stage times, individual items, missing cases, interviews, and project conditions together. Select a delay that is repeated, unpredictable, or costly enough to address. Describe where it happens and why you think it occurs, with a few examples. Separate what you know from what the trial will help you find out.
Different causes call for different changes. Pipeline feedback can be slow because jobs wait for runners, jobs execute slowly, pipelines repeat work, or unreliable jobs cause retries. Review can be slow because ownership is unclear, changes are too large, reviewers lack capacity, or a specialist risk check is necessary. A generic request for more automation doesn't resolve those differences.
Match the trial to the size of the change. Fixing an ownership route or cache key may suit a small trial. Changing the branch model, runner fleet, test architecture, or release process needs broader design and a longer review.
Try a change in everyday work
Use an existing backlog issue to agree on the change and who will take it forward. Choose a project that resembles the teams likely to adopt it. Before starting, decide when you'll review the result and how you'll reverse the change if it makes work harder.
Capture the starting point before making the change, then gather results and feedback from normal work during the trial. Record unexpected effects and tradeoffs, including work shifted to another team. Review these with the people who will support the approach before expanding it. For a wider rollout, decide what success looks like in each group of projects and how to reverse the change if it makes their delivery path worse.
Choose measures that describe the work, such as review wait, retries, or time through to release. Check quality and developer effort alongside speed. Choosing measures that guide improvement helps you decide what to compare and how to interpret mixed results.
For example, a wait for review
A team's Review stage is long and highly variable. Sampled merge requests often wait before discussion begins. Developers say reviewer ownership is unclear; workflow owners believed authors knew whom to request. The changes are small and their pipelines finish quickly, so adding pipeline automation would not address the delay.
The team records Review duration and manually checks time to reviewer assignment. Failed deployments and post-merge defects are safety checks. In one representative project, it introduces a review rotation, updates ownership information, and defines a route for specialist changes.
At the review date, the team checks comparable work, total request-to-production time, safety checks, and developer feedback. If the rotation only moves the queue to one person, the team changes or stops it. If assignment is faster and the rest of delivery remains healthy, the team can expand it.
Decide whether to keep or expand the change
Bring the results back to the people involved and decide whether to keep the change, adjust it, stop it, or try it more widely. Explain the decision with real examples and developer feedback. If the result is unclear, check whether you need better records or more time to see the effect.
For expansion, start with projects that have similar branch models, controls, and release methods. Give their teams a way to get help and review the effects before moving further. Carry what you learn into the guidance for the next group, especially when their delivery process differs. Helping teams adopt a new workflow explains how to follow a rollout beyond its initial setup.
Tradeoffs
- Completed work can hide the worst delays. Stage results may omit unfinished or abandoned work. Keep a separate list of blocked, reopened, and unusually old items.
- A median can hide a long tail. Review individual durations and unusual cases beside the typical stage time.
- Labels can create misleading precision. If a label is applied late or inconsistently, the resulting duration doesn't represent the real transition.
- A necessary control may take time. The aim is to remove needless waiting and make required review predictable, not to make every stage as short as possible.
- A faster stage can move the queue. Check total delivery time and safety checks so that a local improvement doesn't create rework, failed deployments, incidents, or a new downstream wait.
- Team comparisons can reward data differences. Begin with one team's trend. Compare teams only after confirming that they record work and use stage events in the same way.
- Interviews require follow-through. Explain that the review studies the delivery system, not individual performance. Tell participants which finding was chosen and what happened after the pilot.
Keep the timeline, stage definitions, sampled records, and review decision together with the improvement work so another team can understand the result or repeat the trial. Include conversation notes or rollout details when they explain an important choice.
Further Reading
Notes
-
Value Stream Analytics includes predefined project stages in Free. Group reporting, custom value streams, and custom stages are available in Premium and Ultimate. ↩
- Value Stream Analytics — Use this to select supported stage events, check calculation behavior, and confirm feature availability and processing notes.
- Reliable DORA and value-stream data helps reconcile missing or inconsistent analytics records before drawing conclusions from a trial.
- Issues explains how to assign and track the chosen improvement with its review date and results.