Alright, let me put the coffee on for this one. ☕ I've been staring at my team's CI bill this month and had a flashback to 2018, when we were on one of those "unlimited minutes" SaaS plans. We thought we were geniuses, saving money. Instead, we built a culture of "just rebuild it" and "add another parallel job."
Here's the thing: when the minutes feel free, you stop optimizing. I remember a frontend pipeline that did a full `npm install` on every single commit, even for docs changes, because it was easier than setting up cache properly. That was burning 20 minutes a pop. No one cared, because the dashboard said "0.00" for the extra time. Fast forward to when we moved to a per-minute vendor. Suddenly, that pipeline became a priority. We got it down to under 4 minutes for most runs.
```yaml
# Before (the "unlimited" mindset):
# job: build
# script:
# - npm ci
# - npm run build
# - npm run test
# After (cost-aware):
# job: build
# cache:
# key: npm-$CI_COMMIT_REF_SLUG
# paths:
# - node_modules/
# script:
# - npm ci --prefer-offline
# - npm run build
# - npm run test
```
The real cost wasn't just the eventual invoice. It was the habit. Unlimited plans teach teams that compute time is infinite. It's like leaving all the lights on in your house because you're on a flat-rate utility plan. You might not see the direct hit, but someone's paying for it, and you're building wasteful practices into your DNA.
So my hot take: those "unlimited" plans are a trap for growing teams. They delay the necessary conversation about efficiency and pipeline hygiene. Once you hit a certain scale, the bill always comes due—either as a shocking invoice from a new provider, or as bloated infra costs if you self-host.
Anyone else lived through this transition? Found a good way to coach teams to be time-conscious even when the meter isn't visibly running?
-- Dad
it worked on my machine
You're absolutely right about the hidden cost of that "unlimited" mindset, but there's an infrastructure dimension often missed. The waste isn't just in billed minutes, it's in the cumulative resource load that can create systemic bottlenecks, especially in self-hosted runners or adjacent systems.
That `npm install` on every commit didn't just consume plan minutes, it saturated network egress and hammered your artifact storage with repeated, identical `node_modules` tarballs. When you moved to per-minute billing, you optimized the pipeline, but you also inadvertently reduced load on your package registry and object storage, which often have their own, separate throttling or costs. The financial incentive aligned with better architectural hygiene.
I've seen teams on unlimited plans hit unspoken rate limits on Docker Hub or GitHub Packages long before they hit any CI minute cap, causing cascading failures. The per-minute model forces you to think about the entire dependency chain, not just the execution time.
Plan the exit before entry.