DEV Community: Shubham

I got tired of guessing my cloud bills, so I built 12 free developer cost calculators (No login, No BS).

Shubham — Thu, 02 Apr 2026 14:40:54 +0000

Hey everyone,

I kept running into the same problem: trying to figure out exactly how much a CI/CD pipeline or a cloud service was going to cost before getting the actual bill at the end of the month. Comparing GitHub Actions vs GitLab CI, or trying to understand AWS Lambda vs EC2 costs, usually meant digging through endless pricing docs and doing the math manually.

So, I built a solution: a suite of 12 free, privacy-first developer cost calculators.

Here are a few of the tools included:

GitHub Actions Cost Calculator: Paste your YAML workflow and instantly see the exact per-run and monthly costs across Ubuntu, Windows, and macOS runners. (Did you know macOS runners cost 10x more than Ubuntu?)
CI/CD Cost Comparison: Compare GitHub Actions, GitLab CI, and CircleCI side-by-side to find the cheapest platform for your specific workflow.
AWS Tools: Lambda vs EC2 calculators, comparing x86 vs ARM Graviton2 architecture (switching to ARM can save you 20% on Lambda).
AI API Rate Limit Calculator: Figure out your max concurrent users and daily request budgets for OpenAI, Claude, Gemini, etc.
Tech Stack Cost Estimator: Estimate your total monthly infra cost combining tools like Vercel, Supabase, Clerk, Resend, etc.

Why I made it free:
Every developer deserves accurate pricing data without hitting a paywall, an email wall, or needing a credit card.

No Signup/Login: Just open and use it.
Fully Private: All calculations run entirely in your browser. Your data never leaves your device.
Up-to-date: Pricing data is updated for 2026.

I've put together a GitHub repo that lists all 12 tools, explains what they do, and has the direct links to use them.

You can check out the full list and access the calculators here:
👉 https://github.com/Shubhamorigin/cloud-cost-calculators

U can directly use it - https://githubactionscost.online
Let me know if you find it useful or if there are any other specific calculators you'd like to see added! Feedback is always welcome.

GitHub Actions Changed Pricing in 2026 — Here's Exactly What You're Paying Now

Shubham — Sat, 28 Mar 2026 04:57:43 +0000

In January 2026, GitHub updated their Actions runner pricing. Most teams didn't notice. Here's exactly what changed and how to calculate your new bill.

2026 Pricing Table

Ubuntu: $0.006/min (was $0.008 — 25% cheaper)
Windows: $0.010/min (was $0.016 — 37.5% cheaper)
macOS: $0.048/min (was $0.080 — 40% cheaper)

Good news — prices dropped.

Bad news — macOS still costs 8× more than Ubuntu. Most teams don't realize this until month-end.

The macOS Trap

10-minute macOS job: $0.048 × 10 = $0.48 per run
10-minute Ubuntu job: $0.006 × 10 = $0.06 per run

20 pushes/day:

macOS → $9.60/day → $288/month
Ubuntu → $1.20/day → $36/month

Same test output. $252/month difference.

5 Ways to Reduce Your Bill

Switch lint/typecheck jobs to Ubuntu — identical output, 8× cheaper
Use path filters — skip CI on docs-only commits
Cache node_modules, pip packages aggressively
Run tests in matrix parallel — same cost, faster
Only use macOS when you genuinely need Apple frameworks

Free Calculator

Paste your YAML → see exact monthly cost:

githubactionscost.online/github-actions-cost-calculator

No signup. Runs in browser. 2026 pricing.

How I Built 11 Cloud Cost Calculators to Solve "Bill Shock" (And Why I'm Moving On)

Shubham — Tue, 24 Mar 2026 15:27:52 +0000

Every developer has been there: You launch a side project on Vercel or AWS, and suddenly, you're hit with a bill you didn't expect.

I decided to solve this by building githubactionscost.online — a suite of 11+ high-precision calculators for Vercel, Netlify, Supabase, and more. Today, I want to share the technical journey and why I'm looking for a new owner to take this forward.

🛠️ The Tech Stack: "Keep it Simple & Static"

I wanted these tools to be lightning-fast and cost $0 to maintain.

Frontend: Pure HTML5, Tailwind CSS, and Vanilla JavaScript.
Architecture: No database. No heavy backend. Everything is calculated client-side for privacy and speed.
Ad-Blocker Proof: Instead of intrusive ads, I hardcoded "Native Recommendation Slots." They are part of the UI, meaning zero revenue loss to ad-blockers.

📈 The Results: 100% Organic Growth

Without spending a single penny on marketing, the platform started ranking for high-intent keywords.

Top Traffic Source: United States (High-intent devs and founders).
Secondary Sources: France, Germany, Canada.
SEO: The calculators rank for keywords where users are actively looking to switch providers—making it a lead-gen goldmine.

🧠 The Pivot: Moving to Aaptics

So, why sell a growing asset?

I’m currently building Aaptics, an AI platform designed to learn and clone your unique writing style. Aaptics is scaling fast and requires my 100% technical focus and capital for GPU infrastructure.

As a founder, I’ve realized that to build something great (Aaptics), I have to let go of other successful projects.

🤝 Looking for a New Owner

I am looking for a strategic exit this week to inject capital into Aaptics' growth.

What you get: Full GitHub repository, premium domain, and a ready-to-monetize Tier-1 traffic engine.
Target Price: Looking for a quick buyout in the $4,000 - $5,000 range.

If you’re a DevOps agency, a hosting provider, or an indie hacker looking for a high-authority asset, let’s talk!

DM me here or reach out via Twitter.

GitHub Actions Changed Pricing in 2026 — Here's Exactly What You're Paying Now (Free Calculator Inside)

Shubham — Mon, 23 Mar 2026 05:49:43 +0000

The Bill That Started This

In January 2026, GitHub quietly updated their Actions pricing.
Ubuntu went from $0.008/min to $0.006/min — a 25% reduction.
macOS went from $0.080/min to $0.048/min — a 40% drop.

Good news, right? Cheaper CI/CD.

Except most teams had no idea this happened.
And many teams are still paying for macOS runners
when Ubuntu would do the same job for 8x less.

The 2026 GitHub Actions Pricing (Official Numbers)

Runner	Old Price	New Price (Jan 2026)	Change
Ubuntu (Linux)	$0.008/min	$0.006/min	-25%
Windows	$0.016/min	$0.010/min	-37.5%
macOS	$0.080/min	$0.048/min	-40%

These are the overage rates after free tier.
Free tier: 2,000 min (Free), 3,000 min (Pro),
50,000 min (Team).

The macOS Problem Nobody Talks About

macOS runners cost 8x more than Ubuntu runners
on the new pricing. Before the update, it was 10x.

Still 8x.

Here's what that means in practice:

# This job on macOS: $0.048/min × 10 min = $0.48 per run
# This job on Ubuntu: $0.006/min × 10 min = $0.06 per run
jobs:
  test:
    runs-on: macos-latest  # ← costs 8x more than ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm test

If you push 20 times per day, that's:

macOS: $9.60/day → $288/month
Ubuntu: $1.20/day → $36/month

For the same test results.

The Windows Trap

Windows runners are 1.67x more expensive than Ubuntu:

Ubuntu: $0.006/min
Windows: $0.010/min

Many teams run cross-platform tests on Windows "just in case"
without checking if their Linux tests already cover it.

Self-Hosted Runner Change (March 2026 Controversy)

GitHub announced charges for self-hosted runners
(ephemeral, network access) — $0.002/min starting March 2026.

This is still significantly cheaper than hosted runners
but it caught many teams off guard who assumed
self-hosted = always free.

Free Minutes — Do You Know Your Limit?

Before any overage kicks in, you get:

Plan	Free Minutes/Month
Free	2,000
Pro	3,000
Team	50,000
Enterprise	50,000

With OS multipliers applied:

2,000 Linux minutes on Free plan
But only 200 macOS minutes (10x multiplier)
Or 666 Windows minutes (3x multiplier)

How to Calculate Your Actual Cost

I built a free calculator that does this instantly:

🔗 GitHub Actions Cost Calculator

Paste your workflow YAML → instant cost breakdown across
all 3 runner types → AI suggestions to reduce costs.

No signup. No account. Runs in browser. Nothing stored.

5 Ways to Reduce Your GitHub Actions Bill

1. Switch lint/type-check jobs to Ubuntu

# Before — expensive
lint:
  runs-on: macos-latest

# After — 8x cheaper, identical output
lint:
  runs-on: ubuntu-latest

2. Use path filters — skip CI on docs changes

on:
  push:
    paths:
      - 'src/**'
      - '!docs/**'
      - '!*.md'

3. Cache dependencies aggressively

- uses: actions/cache@v4
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}

4. Run jobs in parallel instead of serial

strategy:
  matrix:
    test-suite: [unit, integration, e2e]
# All 3 run simultaneously — same total time, 
# same total cost, but faster wall-clock

5. Only run macOS when you truly need it

test:
  strategy:
    matrix:
      os: [ubuntu-latest, macos-latest]
  runs-on: ${{ matrix.os }}
  # Ask: does your macOS test find bugs Ubuntu misses?
  # If not, remove macos-latest from the matrix

The Bigger Picture — 11 More Billing Surprises

GitHub Actions is just one piece.

After I built that calculator, I realized the same problem
existed across the whole developer tooling ecosystem:

Docker Hub now throttles unauthenticated pulls to
10/hour (down from 100/6hr) — shared CI runner IPs
mean your builds fail because of other users
Firebase bills per Firestore document read —
one bad list query can cost $179/month
Netlify's new credit system makes bandwidth overage
cost $0.55/GB vs Vercel's $0.15/GB — 3.7x difference

I built free calculators for all of these:

→ DevCost Tools — All 12 Calculators

CI/CD, AWS Lambda, CodeBuild, Vercel vs Netlify,
Supabase vs Firebase, Docker Hub, CircleCI, GitLab CI,
AI API rate limits, full tech stack estimator.

All free. All 2026 pricing. All browser-side calculations.

Quick Reference — 2026 Pricing Cheat Sheet

GitHub Actions
  Ubuntu:  $0.006/min  (1x multiplier)
  Windows: $0.010/min  (1.67x multiplier)  
  macOS:   $0.048/min  (8x multiplier)

GitLab CI
  All OS:  $0.010/min flat  (no multiplier!)
  macOS:   6x compute minutes consumed

CircleCI
  Linux:   $0.006/min (10 credits/min)
  macOS:   $0.060/min (100 credits/min)
  1 credit = $0.0006

AWS Lambda
  x86:     $0.0000166667/GB-s
  ARM:     $0.0000133334/GB-s  (20% cheaper)
  Free:    1M requests + 400K GB-s/month

Docker Hub
  Unauth:  10 pulls/hour per IP
  Free:    100 pulls/hour per user
  Paid:    Unlimited

Which of these billing surprises caught you off guard?
Let me know in the comments 👇

And if this saved you from a surprise bill —
share it with one teammate who runs macOS builds.

Stop Flying Blind: How to Calculate and Optimize GitHub Actions Costs in Real-Time

Shubham — Sun, 22 Mar 2026 05:30:09 +0000

The Problem: The "Bill Shock" of 2026

In January 2026, GitHub updated its pricing model for runners and introduced new fees for certain self-hosted configurations. For many teams, CI/CD went from a "background cost" to a major line item on the monthly invoice.

The problem isn't just the cost; it's the unpredictability. How much does that new integration-test.yml actually cost per month? Usually, you only find out after the bill arrives.

Introducing GitHubActionsCost.online

I built githubactionscost.online to give developers a free, instant way to estimate and optimize their workflow spend before they even hit "git push."

🧠 How it Works: Technical Deep Dive

1. Zero-Trust YAML Parsing

Privacy is a major concern when handling infrastructure code. Instead of sending your YAML files to a backend server, the tool uses Client-Side Parsing.

The parsing logic is written in vanilla JavaScript that runs directly in your browser.
Your workflow secrets, job names, and logic never leave your machine.
It calculates costs based on the duration ($T$) and the specific runner rate ($R$) using the formula: $$Cost = T \times R$$

2. Side-by-Side Runner Comparison

The tool fetches the latest 2026 rates for Ubuntu, Windows, and macOS runners. It provides a clear comparison so you can see exactly how much you save by switching OS or using smaller instances.

3. AI-Powered Workflow Optimization

This is where the real savings happen. By integrating with the OpenRouter API, the tool analyzes your YAML structure to find "leaks."

Missing Timeouts: Jobs that hang can drain your credits.
Caching Opportunities: Identifying steps where actions/cache can shave off minutes.
Matrix Optimization: Consolidating jobs to reduce overhead.
Impact: Users have seen cost reductions of 40% to 60% just by following these AI suggestions.

🛠 The Stack

Frontend: Vanilla HTML/CSS/JS (for maximum speed and no-bloat).
Hosting: Vercel (Global Edge Network).
AI Engine: OpenRouter (providing access to the latest LLM models for workflow analysis).

Why I Built This

CI/CD should be a leverage, not a liability. By providing a transparent way to calculate costs—per run, per day, or per year—developers can make informed decisions about their automation infrastructure.

If you're tired of guessing your GitHub bill, give it a try. It’s open, free, and privacy-first.

Check it out: githubactionscost.online

I Built a Free GitHub Actions Cost Calculator Over a Weekend. Here's What 7 Days of Data Taught Me.

Shubham — Sat, 21 Mar 2026 05:14:57 +0000

Last month I got an email from GitHub.

Pricing changes. Effective January 2026. Self-hosted runners now have a per-minute fee attached.

I did the math for our team's workflows. The numbers were not catastrophic, but they were not small either. And the frustrating part was that I had to do that math manually — in a spreadsheet, looking up runner rates, estimating step times, multiplying everything out.

There had to be a better way.

So I built one.

What I Built

githubactionscost.online — a free GitHub Actions cost calculator.

Paste your workflow YAML. Get the exact cost per run, daily, monthly, and yearly. See what the same workflow would cost on Ubuntu, Windows, and macOS runners side by side. Then get AI-powered suggestions with copy-paste YAML code to cut your bill.

No account. No signup. No credit card. Your YAML never leaves your browser for the calculation part.

I built it in a weekend. Shipped it. And here is what happened.

The Numbers After 7 Days

I did not promote it anywhere. No Reddit post. No Hacker News. No tweet. Just deployed it and watched Google Analytics.

109 active users in 7 days.

That might sound small. But zero promotion, seven days, and a very niche developer tool? I will take it.

What surprised me more than the traffic was where it came from.

United States — 46 users (42%)
Makes sense. GitHub's largest user base.

France — 10 users (9%)
Did not expect this at all.

India — 6 users (5.5%)
Smallest number but by far the most engaged. Average session time of 6 minutes and 5 seconds. Engagement rate of 58%. These users actually used the tool.

Germany, Netherlands, UK, Poland, China, Colombia — all showed up organically.

Organic traffic from 10 countries in 7 days with zero promotion tells me the search intent is real right now.

Why GitHub Actions Costs Are Confusing

Most developers set up a workflow, get it working, and forget about it. The billing is abstracted away until the monthly invoice arrives.

Here is what catches people off guard.

GitHub charges different rates depending on which runner you use. And the difference is not small.

Runner	Cost Per Minute
Ubuntu (Linux)	$0.008
Windows	$0.016
macOS	$0.080

That macOS number deserves a moment of attention.

macOS runners cost 10 times more than Ubuntu runners. Per minute.

If you have a 10-minute workflow running on macos-latest instead of ubuntu-latest, and it triggers 20 times per day, the annual cost difference is over $5,000.

Most developers using macOS runners do not need macOS runners. They copied a workflow template, it had macos-latest in it, it worked, and they moved on. Nobody audited the runner choice.

That is exactly the kind of thing this tool surfaces.

A Real Example

Here is a standard Node.js workflow:

name: CI Pipeline
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '18'
      - run: npm install
      - run: npm run build
      - run: npm test
  deploy:
    runs-on: ubuntu-latest
    needs: build
    steps:
      - uses: actions/checkout@v3
      - run: docker build -t myapp .
      - run: docker push myapp

Running this 10 times per day costs approximately $205 per month.

The AI suggested three changes:

1. Add npm caching

- uses: actions/cache@v4
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}

Saves about 2 minutes per run by not re-downloading packages every time.

2. Add concurrency groups

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

Cancels outdated runs when new commits push quickly. If you push 3 times in 5 minutes, only the last one runs.

3. Use npm ci instead of npm install

- run: npm ci

Faster and more deterministic in CI environments.

Result: estimated monthly cost drops from $205 to around $85. That is 58% savings from three YAML changes.

How the Cost Calculation Actually Works

The tool parses your YAML using js-yaml in the browser. Then it estimates time for each step based on a database of known action timings.

actions/checkout — approximately 15 seconds.
actions/setup-node — approximately 20 seconds.
npm install — approximately 120 seconds.
docker build — approximately 180 seconds.
npm test — approximately 180 seconds.

It adds these up, rounds up to the nearest minute, multiplies by the runner's per-minute rate, and shows you per-run, daily, monthly, and yearly costs for every job.

Then it shows you the same job's cost across all four runner types side by side — Ubuntu, Windows, macOS, and self-hosted — so you can see immediately if you are on an expensive runner unnecessarily.

The AI suggestions come from a serverless function that sends your workflow structure to an LLM and asks for specific optimizations. The model returns JSON with titles, descriptions, savings estimates, priority levels, and copy-paste YAML code examples.

What I Learned Building This

The non-code work takes longer than the code.

Building the actual tool took a weekend. The domain purchase, DNS setup, Vercel deployment, SSL, privacy policy, terms, Google Analytics, Search Console verification, sitemap submission — that took another 3 days. For small solo projects, the launch infrastructure is real work.

Zero-friction tools get organic traffic.

I did not promote this anywhere and 109 people showed up in 7 days purely from search. Developer tools that solve a specific, searchable problem get found.

Timing matters more than most people think.

GitHub's pricing change in January 2026 created a search spike. The keywords "github actions price" and "github actions cost" are trending right now. Building a tool that matches a trending search intent is different from building a tool and then hoping people search for it.

The most engaged users are not always the largest segment.

India was 5.5% of my traffic but 58% engagement rate and 6 minutes average session time. The US was 42% of traffic but 4% engagement and 1 second average session. Knowing which segment actually uses your product versus which one bounces is important for understanding who you are really building for.

What Is Next

The tool is live and working. Promotion starts now — starting with this article.

After that: Hacker News, Reddit communities, and finding the right GitHub repositories where cost-conscious developers are already having this conversation.

If you use GitHub Actions and have not audited your runner choices recently — paste a workflow into the calculator. It takes about 30 seconds and might save you more than you expect.

githubactionscost.online — free, no signup, no data stored.

Built with vanilla HTML/CSS/JS, Vercel serverless functions, and OpenRouter for the AI suggestions. The entire frontend is a single HTML file.

The 3-line YAML mistake that quietly drains your GitHub Actions minutes (and how I built a local parser to catch it)

Shubham — Fri, 20 Mar 2026 04:43:24 +0000

We’ve all been there. You want to ensure your open-source library or SaaS works across all operating systems, so you proudly write this beautiful, innocent-looking matrix strategy in your .github/workflows/ci.yml:

jobs:
  test:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]

Looks harmless, right?

What GitHub’s documentation buries in the fine print is the Runner Multiplier Tax.
While Ubuntu runs at the base rate ($0.008/min), Windows costs 2x more, and macOS costs a staggering 10x more ($0.080/min).

If your test suite takes 15 minutes to run, that single macos-latest line just cost you $1.20 per run. If you have a team pushing 10 commits a day, you are burning hundreds of dollars on macOS runners for code that probably only needed Linux testing.

The Problem: Bill Shock is a lagging indicator

By the time you see the GitHub billing dashboard at the end of the month, the damage is already done. I wanted a way to see the exact cost before I committed the YAML.

But here is the catch: No sane developer is going to paste their company’s proprietary CI/CD infrastructure code into a random third-party website.

The Solution: A 100% Client-Side Cost Calculator

I decided to build a standalone web tool to solve this: GitHub Actions Cost Calculator.

Instead of building a backend that ingests and stores your YAML (which is a massive security red flag), I built the entire parsing engine to run locally in your browser.

Here is how the architecture works:

Zero Server Dependency: You paste your YAML, and a client-side JS parser breaks down the jobs, steps, and runs-on variables.
The 10x Exposer: It immediately splits the cost projection side-by-side (Ubuntu vs. Windows vs. macOS), exposing exactly how much that matrix strategy is costing you per day/month/year.
AI Optimization: It runs a quick heuristic check to suggest caching (actions/cache) and runner downgrades to slash the bill by up to 60%.

Because everything happens in your browser DOM, your YAML is never stored, logged, or sent to a database. ### Test your heaviest workflow

If you are managing CI/CD for your team, I challenge you to drop your heaviest, most complex workflow file into the calculator. You might be surprised by how much that one macOS job is silently eating your budget.

Try it out here (no signup required): www.githubactionscost.online

I'm a solo dev building this out, so if you find any edge cases with complex matrix arrays or reusable workflows that the parser misses, let me know in the comments! How do you guys currently monitor your Actions billing?

I accidentally built a "Zero-Trust" trap for developers (and how I fixed my 2-second bounce rate)

Shubham — Thu, 19 Mar 2026 04:47:15 +0000

Hey DEV community 👋,

I recently built a side project: A GitHub Actions Cost Calculator. The goal was simple—help devs figure out exactly how much their CI/CD pipelines are burning through their wallets before the actual GitHub invoice arrives.

I coded it, made the UI clean, and deployed it. I was pretty proud of it. Then, I shared the link on a few tech forums and checked my Google Analytics a couple of days later.

The data was a massive reality check. 📉

The Brutal Analytics:

Total Active Users: 68
Event Count: 366
The US Traffic Average Engagement Time:... 2 seconds. 💀

Yes, 2 seconds. People were clicking the link, the page was loading, and they were instantly mashing the back button.

But here is the crazy part: A small segment of users (mostly from India) had an average engagement time of 11 minutes and 14 seconds. They were running massive, heavy calculations.

Why the huge divide? What was making 80% of devs run away in 2 seconds?

The "Zero-Trust" Epiphany
I looked at my UI like a new user and realized my massive mistake. The very first thing my app asked the user to do was: "Upload your YAML file."

I forgot the golden rule of building for developers: Developers are inherently (and rightfully) paranoid.

If you drop a link to a random new tool and ask a dev to upload their infrastructure/pipeline logs, their brain instantly goes: "Nope. Is this saving my data? Is this leaking my workflow to a server?"

Even though my code processed everything 100% locally in the browser, the perception of friction and risk was too high. They didn't have the time to audit my network tab.

The 5-Minute Fix
To fix this, I didn't change the core logic. I changed the UX.

The Privacy Badge: Added a massive "100% Private - Processed Locally in your Browser" badge.
The "Lazy Developer" Button: I added a "Load Example" button.

The Challenge for You
If you are building micro-tools, never underestimate the power of dummy data. You have to let users experience the "Aha!" moment of your tool before asking them for their data.

I’m currently testing if this new UX actually converts those 2-second bounces into engaged users.

If you have 30 seconds, I'd love for you to try it and give me brutal feedback on the logic.
Here is the link: githubactionscost.online

P.S. - Do not upload your own file if you don't want to! Just click the "Try with Dummy Data" button and let me know if the cost calculation logic holds up against your own mental math. Let me know what you think! 👇

How to stop overpaying for GitHub Actions (And a free tool to fix it) 💸

Shubham — Wed, 18 Mar 2026 05:34:53 +0000

If you are a developer or a DevOps engineer, you probably love GitHub Actions. It’s seamlessly integrated and easy to set up. But there is one universal truth we all figure out eventually: GitHub Actions pricing can be incredibly confusing, and the bills can escalate quickly.

The biggest trap? The runner multipliers.
Running a job on an Ubuntu runner is cheap, but the moment you switch to a Windows runner, you are paying 2x. Switch to a macOS runner, and suddenly you are paying 10x the per-minute rate.

If you have a complex .yaml file with matrix builds across different OS environments, estimating your end-of-month cost is basically a guessing game.

I got tired of doing this math manually, so I decided to build a solution.

Enter: GitHub Actions Cost Calculator 🛠️

I built a completely free, visual calculator that does the math for you.

Link: githubactionscost.online

How it works:

You just paste your workflow .yml or .yaml file into the editor.
It parses your jobs, steps, and OS environments instantly.
It gives you a clear comparison of how much that workflow will cost across Ubuntu, Windows, macOS, and even Self-Hosted runners.

The Magic Feature: AI Optimization 🧠

Just knowing the price isn't enough; you need to reduce it. I integrated an AI-powered analyzer that reads your specific YAML architecture and suggests actionable ways to cut your execution time.

By applying these suggestions (like aggressive dependency caching, fixing missing step timeouts, or optimizing matrix strategies), you can realistically cut your CI/CD costs by 40% to 60%.

Built with Vanilla Tech & 100% Private 🔒

As developers, we are naturally (and rightfully) paranoid about pasting our infrastructure code into random websites.

Tech Stack: I built this entirely with Vanilla HTML, CSS, and JS. It is lightning-fast and has zero bloat.
Privacy First: There is no backend database storing your workflows. The parsing and calculation happen on the fly. Your secrets and architecture remain yours.

It requires no signup and is completely free to use.

I would absolutely love for the Dev.to community to try it out! Drop your workflow in there and let me know if the AI suggestions helped you find any cost-saving loopholes.

Any feedback, edge cases I missed, or feature requests are highly appreciated! 👇

GitHub Actions Changed Their Pricing — Here's a Free Calculator to See Your Exact Bill

Shubham — Mon, 16 Mar 2026 10:48:16 +0000

I got a surprise bill from GitHub last month.

My team had been running GitHub Actions workflows for months. We assumed the costs were minimal. Then January 2026 arrived, GitHub changed their pricing, and suddenly the numbers looked very different.

The worst part was not the bill itself. The worst part was that I had no idea how to estimate what we were actually paying before it happened.

GitHub's billing dashboard shows you what you spent. It does not show you what you will spend. It does not compare runner costs. It does not suggest optimizations. It just shows a number after the fact.

So I built a tool to solve that problem.

What I Built

githubactionscost.online — a free GitHub Actions cost calculator that takes your workflow YAML and tells you exactly what it costs, across all three runner types, with AI-powered suggestions to reduce your bill.

No signup. No credit card. No account. Paste your YAML, get your numbers.

The Runner Pricing Problem Nobody Talks About

Here is something that shocked me when I first looked into this seriously.

GitHub charges different rates depending on which runner you use:

Runner	Cost per Minute
Ubuntu (Linux)	$0.008
Windows	$0.016
macOS	$0.080
Self-hosted	$0.002

That macOS number is not a typo.

macOS runners cost 10 times more than Ubuntu runners.

If you have a 10-minute workflow running on macos-latest instead of ubuntu-latest, and it runs 20 times per day, here is what that difference looks like over a year:

Ubuntu: $0.008 × 10 min × 20 runs × 365 days = $584/year
macOS: $0.080 × 10 min × 20 runs × 365 days = $5,840/year

A $5,256 per year difference. Just from the runner choice.

And the scary thing is how easy it is to accidentally use the wrong runner. Copy-paste a workflow from Stack Overflow. Use a template. Forget to check. That is how it happens.

How the Calculator Works

You paste your .github/workflows/your-file.yml into the tool. It does three things.

First — Cost calculation.

The tool parses your YAML and estimates how long each step takes based on a database of known GitHub Actions timing data. actions/checkout takes about 15 seconds. npm install takes about 120 seconds. docker build takes about 180 seconds. It adds these up, multiplies by your runner's per-minute rate, and shows you the cost per run, daily, monthly, and yearly.

Second — Runner comparison.

For every job in your workflow, it shows you what that exact job would cost on Ubuntu, Windows, macOS, and self-hosted runners side by side. This makes it very obvious when you are using an expensive runner unnecessarily.

Third — AI optimization suggestions.

It sends your workflow to an AI model which analyzes the structure and gives you 5 specific, actionable suggestions with copy-paste YAML code examples. Things like enabling caching, parallelizing jobs, adding concurrency limits, and switching runners.

A Real Example

Here is a typical Node.js CI workflow:

name: CI
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '18'
      - run: npm install
      - run: npm run build
      - run: npm test
  deploy:
    runs-on: ubuntu-latest
    needs: build
    steps:
      - uses: actions/checkout@v3
      - run: docker build -t myapp .
      - run: docker push myapp

Running this 10 times per day costs approximately $204/month.

The AI suggested three changes that bring it down to around $85/month:

1. Enable npm caching

- uses: actions/cache@v4
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}

Saves about 2 minutes per run by not re-downloading packages every time.

2. Add concurrency groups

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

Cancels outdated runs when new commits are pushed. If you push 3 commits quickly, only the last one runs.

3. Use npm ci instead of npm install

- run: npm ci

Faster and more deterministic in CI environments.

Three changes. Monthly cost drops from $204 to $85. That is 58% savings.

Why This Matters More Now

GitHub changed their pricing in January 2026. Self-hosted runners now have a charge attached. Hosted runner prices were adjusted. Many developers who had set up workflows and forgotten about them are now seeing different numbers on their bills.

This is exactly the time to audit your workflows. Not after you get the bill. Before.

What the Tool Does Not Do

I want to be honest about the limitations.

The time estimates are approximations. Your actual npm install might take 90 seconds or 150 seconds depending on your package count, network conditions, and cache state. The tool uses averages based on common patterns.

For exact numbers, GitHub's billing dashboard is the source of truth. Use this tool for estimation and optimization discovery, not for precise financial forecasting.

How to Use It

Go to githubactionscost.online.

Paste your YAML or upload your workflow file directly.

Set how many times your workflow runs per day using the slider.

Click Analyze.

You get instant cost results. The AI suggestions load in a few seconds after that.

Everything runs in your browser for the cost calculation part. Your YAML is not stored. No account needed.

The Bigger Picture

GitHub Actions is genuinely excellent. I am not writing this to criticize it. The product is powerful, the integration is seamless, and for most teams the cost is very reasonable.

But like any infrastructure cost, it is worth understanding. The developers who get surprised by bills are almost always the ones who set up workflows quickly, got them working, and never looked at the pricing details.

This tool exists to close that information gap. See what you are paying. Understand why. Make an informed choice about whether to optimize or not.

Sometimes you look at the numbers and realize the cost is totally fine for what you are getting. That is a valid outcome too. The point is to know.

Try It

githubactionscost.online — free, no signup, works with any GitHub Actions workflow.

If you find it useful, sharing it with your team or in your developer communities would genuinely help. I built this as a solo project and every visitor helps it grow.

If you find bugs or have suggestions, I am actively working on it and genuinely want the feedback.

Built with vanilla HTML, JavaScript, Vercel serverless functions, and OpenRouter for the AI suggestions.