How to see where your CI/CD pipeline time goes
A slow pipeline costs twice: in CI minutes, and in every developer waiting for a green check. The usual advice is to "make it faster" — but faster what? The test suite, the build, the dependency install, or the five minutes the job spent waiting for a runner? You cannot answer that from a single total. You need the run laid out on one time axis, stage by stage.
This tool draws that axis where your data already is: on your own device. When you paste a log or a stage list here, your browser:
- Reads the timings — GitHub Actions steps from their timestamped ##[group]Run lines, GitLab stages from section_start / section_end markers, timestamped stage lines from Jenkins and CircleCI logs, or durations straight from a stage list ("build: 4m 32s") or JSON.
- Draws the timeline — every stage as a bar drawn to scale on a shared time axis, with parallel jobs on separate lanes, so you can see what ran side by side and what ran alone.
- Flags what matters — the slowest stages, any stage taking 25% or more of the run (a bottleneck), idle gaps where nothing was running, and wait/queue time — plus a downloadable report with every stage's start, end, duration and share.
What makes this visualizer different
The established pipeline analytics — GitLab CI/CD analytics, Datadog CI Visibility, the Backstage CI/CD Statistics plugin — live inside the platform: you need an account, a project, and usually a paid plan, and they show trends across runs rather than one run's timeline. The dedicated tools that do show a run timeline — pipescan, Workflow Metrics, ci-time-tracker — need you to connect your GitHub account, install a CLI, or add an action to your workflow. Nothing we found takes a pasted log or a stage list from any CI system and draws the timeline instantly, in the browser, with no account and no connection. That is the gap this page fills: the fastest way from "my pipeline takes 18 minutes" to "the integration tests take 6 of them, and nothing ran for 46 seconds in the middle".
When is visualizing the right choice — and when is it the wrong one?
Visualizing is right when a run feels slow and nobody can say why, when you are about to spend a sprint speeding up CI and want to spend it on the right stage, and when you want a report to attach to a pull request or a team discussion. It is the wrong choice for tracking trends across hundreds of runs — this tool reads one run at a time and keeps no history. It is also the wrong choice as a source of truth for billing: CI minutes are what your provider charges, and this tool measures what your log records, which is not always the same thing.
Honest limitations
Timing parsing is heuristic
Log formats vary between CI systems and versions. A GitHub Actions log with clean group timestamps times well; a Jenkins log without the timestamps plugin cannot be timed at all. When the tool cannot find timings, it says so instead of guessing.
A stage list is sequential by default
Without start/end times, stages are drawn one after another in the order listed. Parallel jobs only appear on separate lanes when the input carries real timestamps.
It never sees your CI system
The tool does not connect to GitHub, GitLab, Jenkins or CircleCI, fetch your runs, or store any history. It only reads what you paste — which is also why your data never leaves the device.
Queue time must be in the log
Wait time is only measured when the log names it ("waiting for a runner", a queued stage). If your CI system does not record when a job was queued, that wait is invisible to this tool.
It shows where, not why
A long stage is a fact; the reason it is long is not in the timings. A 6-minute test suite may be slow tests, a slow runner, or a flaky retry — the timeline tells you where to look, not what you will find.
It never changes your pipeline
This tool only reports and downloads a new report. Your pipeline files and CI configuration are never modified — to speed a stage up, change the pipeline yourself and re-visualize.