See where your CI/CD pipeline time actually goes.

Paste a pipeline log or a stage list — get a stage timeline, the slowest stages, idle gaps and a downloadable report. No CI account, no sign-up, nothing uploaded.

  • Your log data never leaves the device
  • GitHub Actions · GitLab CI · Jenkins · CircleCI
  • Bottlenecks + idle gaps flagged
  • Heuristic timing, honestly stated

Paste a pipeline log or a stage list

One stage per line with a duration ("build: 4m 32s"), a full CI log with timestamps, or JSON — [{"name": "build", "duration": "4m 32s"}]. Start/end ranges work too: "build: 0s - 4m 32s". Drop up to 10 files (5 MB each) below.

Try a sample:

Drag & drop log files here

or browse your files

Parsed in your browser — every stage is drawn to scale with its share of the run. Nothing is uploaded.

    No text or files yet. Everything stays on this device. Reports download instantly.

    Privacy you can verify, not just trust

    Your pipeline logs name your repositories, your job names, your infrastructure — the map of how your team ships. Sending them to a hosted analyzer means handing that map to a stranger's server. This one can't: your text and files are parsed entirely in your browser. Your file data never leaves the device — the only third-party requests are the site's own analytics, which count page views — and it uploads nothing, ever. There is no file fetched after load for the visualization itself. Don't take our word for it:

    New cross-origin requests during use: 0
    1. Press F12 to open developer tools, then the Network tab.
    2. Visualize a log above. Watch: apart from the site's analytics, nothing new is requested — no uploads, and no file data ever leaves your device.
    3. Extra credit: disconnect your internet after this page loads — visualizing still works.

    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:

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

    Frequently asked questions

    Do my logs upload anywhere?

    No. Your text and files are analysed entirely in your browser — your file data never leaves the device, and the only third-party requests are the site's own analytics, which count page views. You can verify it yourself with the network-request counter in the privacy section below the visualizer.

    Which CI systems does it understand?

    GitHub Actions logs (timestamped ##[group]Run steps), GitLab CI logs (section_start / section_end markers), Jenkins and CircleCI logs with timestamped stage lines, a simple stage list (one stage per line, such as 'build: 4m 32s'), and JSON arrays of stages with a duration or a start/end pair. Any other log that names stages with timestamps is read on a best-effort basis.

    What counts as a bottleneck?

    Any stage that takes 25% or more of the run's wall time is flagged as a bottleneck and drawn in red on the timeline. The longest stage is named in the summary. A bottleneck is where to look first — but a stage can be long because it is genuinely doing the most work, so read the share before deciding it is waste.

    What is an idle gap, and why does it matter?

    An idle gap is a stretch of the run where no stage is running — the pipeline is waiting on something, usually a free runner, a manual approval, or a download. Gaps of 10 seconds or more, or 5% of the run, are listed separately. Idle time is often the cheapest time to win back: it needs no faster tests, just less waiting.

    My log has no per-stage timestamps — will it still work?

    Yes, if you paste a stage list instead: one stage per line with its duration, such as 'build: 4m 32s'. The stages are then drawn one after another in the order you list them. A plain log without timestamps or stage markers cannot be timed, and the tool says so instead of guessing.

    How are parallel jobs shown?

    Jobs that overlap in time are drawn on separate lanes of the same timeline, so you can see at a glance what ran side by side and what ran alone. Parallel lanes only appear when the input carries real timestamps — a plain stage list is drawn as one sequential lane.

    What does the downloadable report contain?

    Wall time, total stage time, busy and idle time, wait/queue time and parallel efficiency, the bottleneck stages, the idle gaps, and a table of every stage with its start, end, duration, share of the run and status — as Markdown for humans or JSON for scripts and dashboards.

    What does this tool NOT do?

    It does not connect to your CI system, fetch your runs, or store any history — it only reads what you paste. It cannot measure queue time the log does not record, and it cannot tell you why a stage was slow, only where the time went. For trends across many runs, use your CI provider's own analytics.