Most CI/CD pipelines are accidentally slow. They start from a clean runner, reinstall the same toolchains, rebuild every crate and container layer, and then call it "reproducible." Reproducibility is good. Wasting hours is not. I design pipelines where the default path is fast and the cache is the source of truth.
Start with a reproducible execution graph
I use Dagger to express CI/CD as a directed acyclic graph of containerized operations. Each step runs in a container, declares its inputs, and produces an output. Because the graph is deterministic, Dagger can cache any node and replay only what changed. A one-line change in a Rust source file no longer triggers a full toolchain reinstall.
Cache like you mean it
Cache volumes are not magic; they need intention. I pin tool versions, vendor dependencies, and separate dependency resolution from compilation. For Rust I mount ~/.cargo/registry and target/ as persistent cache volumes and run cargo fetch as its own cached step. For Node I do the same with node_modules and lockfiles. The result: dependency installs usually take zero seconds on subsequent runs.
Parallelize the bottleneck
Lint, test, type-check, and build can run in parallel when they share the same cached dependency layer. Instead of a sequential script, my Dagger pipeline fans out independent checks and fans back in for the deployable artifact. Failures surface in seconds, not at the end of a twenty-minute monolith.
Local == remote
The same pipeline runs on a developer laptop and in CI. This removes the entire class of "works on my machine" surprises and lets engineers debug CI failures locally with the same container graph. When your pipeline is code, not YAML, you get reuse, review, and versioning for free.
If your team is fighting multi-hour builds, the fix is usually not a bigger runner. It is a clearer graph, better caching, and parallel execution. I have helped clients cut build times by 10x without changing their application code. If that sounds useful, get in touch.