A load balancer is a meter before it is a feature. The Application Load Balancer, the Network Load Balancer, and Google Cloud's load balancer all move packets from the internet to your servers — and they bill for it in three different ways. AWS charges by the hour plus a capacity unit that bills on whichever dimension you use most. Google charges by the forwarding rule plus a fee per gigabyte processed. At low volume the difference is a few dollars a month. At high volume it is hundreds. This playbook prices all three from the vendors' own pricing pages, at three stated traffic volumes, with every number worked out in the open.
How each one charges
The ALB is AWS's Layer 7 load balancer — content-based routing, host and path rules, TLS termination. Its price has two parts: $0.0225 per hour for the load balancer itself, plus $0.008 per LCU-hour. A partial hour is billed as a full hour. The LCU is the meter: 25 new connections per second, 3,000 active connections per minute, 1 GB processed per hour for EC2, container or IP targets (0.4 GB per hour for Lambda targets), or 1,000 rule evaluations per second. You are charged only on the dimension with the highest usage, and the first 10 rules are free. AWS also sells reserved LCUs — up to 15,000 per ALB, per the quotas page — which reserve capacity rather than discount it; this playbook prices on-demand only.
The NLB is AWS's Layer 4 load balancer — it distributes traffic across EC2 instances, containers, and IP addresses in one or more Availability Zones, without inspecting the content. Its price is the same hourly rate, $0.0225 per hour, plus $0.006 per NLCU-hour. The NLCU dimensions are far more generous for connections: for TCP, 800 new connections per second, 100,000 active connections, and 1 GB processed per hour; for UDP, 400 new flows per second and 50,000 active connections; for TLS, 50 new connections per second and 3,000 active connections. The cheaper unit and the larger connection allowances are the whole reason the NLB wins on connection-heavy traffic.
Google Cloud charges differently. A load balancer costs $0.025 per hour for the first 5 forwarding rules, then $0.01 per hour for each additional rule, plus $0.008 per GiB of inbound data processed and $0.008 per GiB of outbound data processed. Google notes that for most load balancing use cases you need only one forwarding rule per load balancer. There is no capacity unit and no per-connection meter — the bill grows with rules and with gigabytes, nothing else. Normal data transfer rates still apply for traffic outbound from a load balancer; this playbook does not price egress, because no egress rate was read this cycle.
The vendors' own examples
Before running our own scenarios, check the vendors' worked examples — they confirm the meter works the way the pricing pages say. AWS's Example 1 for the ALB assumes 1 new connection per second, a 2-minute duration, 5 requests per second, 300 KB per second, and 60 rules. That works out to 1.08 LCUs:
ext{ALB example LCU charge} = 1.08 imes $0.008 = $0.00864 ext{ per hour}
ext{ALB example monthly LCU charge} = $0.00864 imes 720 = $6.22
ext{ALB example total} = ($0.0225 + $0.00864) imes 720 = $22.42 ext{ per month}
AWS's Example 1 for the NLB uses the same traffic and works out to 1.08 NLCUs:
ext{NLB example total} = ($0.0225 + 1.08 imes $0.006) imes 720 = $20.87 ext{ per month}
Two things to notice. First, AWS's examples use a 720-hour month (24 hours × 30 days); Google's uses a 730-hour month, and our scenarios below use 730 hours — never mix the two bases inside one calculation. Second, at this tiny volume the ALB and NLB are within $1.55 a month of each other. The gap only opens when traffic grows. One cent of housekeeping: AWS's page prints $20.86 for the NLB example, because it rounds the hourly rate to $0.0289 first; the $20.87 above is the exact arithmetic from the stated inputs.
Google's worked example assumes a load balancer in Iowa with 10 forwarding rules and 2,048 GiB of inbound data processed in a month:
ext{GCP example total} = ($0.025 + 5 imes $0.01) imes 730 + 2{,}048 imes $0.008 = $54.75 + $16.38 = $71.13 ext{ per month}
The rule fee dominates at this volume — $54.75 of the $71.13 — because 2,048 GiB is small. That balance flips as traffic grows.
The decision table
| Load balancer | Hourly fee | Capacity / data fee | Bills most on | Best when | Authority |
|---|---|---|---|---|---|
| AWS ALB | $0.0225/hr | $0.008/LCU-hour | Whichever LCU dimension is highest | Layer 7 routing, moderate connections | AWS ELB pricing |
| AWS NLB | $0.0225/hr | $0.006/NLCU-hour | Whichever NLCU dimension is highest | High connections, TCP/UDP/TLS passthrough | AWS ELB pricing |
| GCP load balancer | $0.025/hr (first 5 rules) | $0.008/GiB in + $0.008/GiB out | Gigabytes processed | Few rules, low to moderate bytes | GCP VPC pricing |
The idle floor
Every load balancer costs money while it exists, even with zero traffic. On a 730-hour month:
ext{ALB idle} = $0.0225 imes 730 = $16.43 ext{ per month}
ext{NLB idle} = $0.0225 imes 730 = $16.43 ext{ per month}
ext{GCP idle (1 rule)} = $0.025 imes 730 = $18.25 ext{ per month}
A sixth GCP rule adds $0.01 per hour, or $7.30 a month. Ten rules cost $0.075 per hour:
ext{GCP 10 rules} = ($0.025 + 5 imes $0.01) imes 730 = $54.75 ext{ per month}
The idle floor is the first thing to check when a bill looks wrong: a load balancer left running in a test project costs about $16 to $18 a month forever.
Scenario A: steady API traffic
A steady API: 10 GB per hour of traffic (5 in, 5 out), 10 new connections per second, 500 active connections per minute, 20 rules, 50 requests per second. For the ALB the byte dimension dominates — 10 GB per hour against 1 GB per LCU — while new connections need only 0.4 LCUs and active connections only 0.17:
ext{ALB Scenario A} = (10 imes $0.008) imes 730 = $58.40 ext{ LCU charge}
ext{ALB Scenario A total} = $58.40 + $16.43 = $74.83 ext{ per month}
The NLB needs the same 10 capacity units, but each costs less:
ext{NLB Scenario A total} = (10 imes $0.006) imes 730 + $16.43 = $60.23 ext{ per month}
GCP has no capacity unit. Its bill is the rule fee plus data processed in both directions — 5 GiB per hour each way is 3,650 GiB a month:
ext{GCP Scenario A total} = $18.25 + 3{,}650 imes $0.008 + 3{,}650 imes $0.008 = $76.65 ext{ per month}
At this volume the NLB is cheapest, GCP is dearest, and the spread is $16.42 a month. The ALB is the middle pick — and the right pick if you need its Layer 7 routing, since $14.60 a month buys content-based rules the NLB cannot do. At 50 requests per second the API serves 4,320,000 requests a day:
The ALB does not bill per request, so do not quote a per-request price for it — the $74.83 is a monthly figure at a stated volume.
Scenario B: high volume
The same API at ten times the bytes: 100 GB per hour (50 in, 50 out), everything else unchanged. The ALB needs 100 LCUs and the NLB 100 NLCUs:
ext{ALB Scenario B total} = (100 imes $0.008) imes 730 + $16.43 = $600.43 ext{ per month}
ext{NLB Scenario B total} = (100 imes $0.006) imes 730 + $16.43 = $454.43 ext{ per month}
ext{GCP Scenario B total} = $18.25 + 36{,}500 imes $0.008 + 36{,}500 imes $0.008 = $602.25 ext{ per month}
At high volume the ALB and GCP converge — $600.43 against $602.25 — while the NLB pulls $146 to $148 a month ahead of both. The reason is the unit price: $0.006 against $0.008, applied a hundred times over. If your traffic is byte-heavy and you do not need Layer 7 routing, the NLB is the cheapest pick at every volume in this playbook. For the wider cloud picture, our AWS vs GCP vs Azure cloud pricing playbook prices the compute behind the load balancer, and our EKS vs GKE vs AKS managed Kubernetes pricing playbook prices the clusters the load balancer usually fronts.
Scenario C: connection-heavy chat
A chat or WebSocket service: 1,000 new connections per second, 100,000 active connections per minute, only 0.5 GB per hour of traffic, 10 rules, 2,000 requests per second. This is where the ALB's meter breaks. Its new-connection dimension needs 40 LCUs — 1,000 divided by 25 — while its active-connection dimension needs 33.33:
ext{ALB Scenario C} = (40 imes $0.008) imes 730 = $233.60 ext{ LCU charge}
ext{ALB Scenario C total} = $233.60 + $16.43 = $250.03 ext{ per month}
The NLB's TCP allowance is 800 new connections per second per NLCU, so 1,000 needs only 1.25 NLCUs:
ext{NLB Scenario C total} = (1.25 imes $0.006) imes 730 + $16.43 = $21.90 ext{ per month}
GCP does not meter connections at all. Its bill is the rule fee plus 182.5 GiB processed each way:
ext{GCP Scenario C total} = $18.25 + 182.5 imes $0.008 + 182.5 imes $0.008 = $21.17 ext{ per month}
The ALB costs more than eleven times the NLB for the same service. This is the single most expensive mistake in this playbook: putting a connection-heavy workload behind an ALB because it is the default. Run your own volumes through our ROI calculator before choosing — the connection count, not the byte count, decides this one.
What the bill leaves out
Three things this playbook deliberately does not price. First, internet egress: normal data transfer rates apply for traffic outbound from a load balancer, and no egress rate was read this cycle, so no combined all-in total is printed — add your region's egress rate to the figures above. Second, units: AWS bills the LCU byte dimension in GB and GCP bills data processed in GiB, and scenario volumes are stated in GB for the AWS math and GiB for the GCP math. One GiB is about 1.074 GB, a 7 percent gap that does not change any ranking in this playbook. Third, the Classic and Gateway load balancers: their rates were not read this cycle and are not printed. If your architecture still runs a Classic load balancer, price it from the same AWS pricing page before comparing — do not reuse the ALB or NLB rates above. Our Cloudflare vs Fastly vs AWS CloudFront CDN pricing playbook covers the layer in front of the load balancer, where cached static objects never transit it at all.
Founder & CEO Insight — Enow A. Jovial
Who should NOT use this
A team that needs Layer 7 routing — host-based routing, path rules, header inspection — should not pick the NLB on price alone; it cannot do what the ALB does, and the $14.60 a month saved in Scenario A is not worth losing the routing. A team already running on GCP should not move to AWS for the NLB's $146-a-month saving in Scenario B without pricing the migration and the egress between clouds. And a team with fewer than a million requests a month should not spend a day on this comparison at all: at that volume every option costs under $25 a month, and the decision is about features, not price.
Execution checklist
- [x] Step 1: Measure your traffic shape: new connections per second, active connections per minute, GB per hour in and out, rules needed — from your current load balancer or access logs, not from a guess.
- [x] Step 2: Compute the ALB LCUs: take the maximum of new connections divided by 25, active connections divided by 3,000, GB per hour divided by 1, and rule evaluations divided by 1,000 — then multiply by $0.008 and add $0.0225 per hour.
- [x] Step 3: Compute the NLB NLCUs: take the maximum of new connections divided by 800, active connections divided by 100,000, and GB per hour divided by 1 — then multiply by $0.006 and add $0.0225 per hour.
- [x] Step 4: Compute the GCP bill: $0.025 per hour for the first 5 rules, $0.01 per hour for each additional rule, plus $0.008 per GiB inbound and $0.008 per GiB outbound.
- [x] Step 5: Compare at your volumes, on a 730-hour month: use the same hour base for all three, and add your region's egress rate before calling any option cheapest.
- [x] Step 6: Delete the load balancers you are not using: an idle ALB or NLB costs $16.43 a month and an idle GCP rule costs $18.25 — test projects are the most common surprise on the bill.

