Egress Fees: The Line Item That Breaks Cloud Budgets
Data transfer is the charge with the weakest intuition behind it. Why outbound traffic is metered, which boundaries cost what, and how to keep bytes on one side.
Ask an engineer to estimate their cloud bill and they will price compute, then storage, then stop. Ask a finance team which line item caused last quarter’s overrun and a surprising share of the time the answer is data transfer. It is the charge with the weakest intuition behind it, because moving bytes feels like something that should be free, and because the architecture that generates it is usually invisible on the diagram.
Egress is worth understanding on its own terms, separately from the general question of why bills grow. The mechanism is specific and so are the fixes.
Why outbound traffic is metered at all
Providers buy transit and peering capacity from network operators and pay for it continuously. Inbound traffic is cheap for them to accept, partly because it attracts workloads and partly because peering settlements tend to favour networks that receive. Outbound traffic is the direction that consumes paid capacity, so that is the direction that carries a charge.
There is a commercial dimension too, and pretending otherwise is unhelpful. Charging for data leaving the platform while accepting data into it for free produces a gradient: it is always cheaper to add to what you have stored than to take it elsewhere. That gradient is one of the main practical components of vendor lock in, which our guide to avoiding vendor lock in treats in more depth.
Rates vary enormously by provider and by destination, and some operators include a generous monthly transfer allowance with each instance instead of metering from the first byte. That structural difference, metered from zero versus included allowance, is often a bigger deal than the headline instance price.
The map of boundaries your bytes can cross
Egress is not one charge, it is a family of them, priced by which boundary the traffic crosses. The boundaries, roughly from cheapest to most expensive, look like this.
| Boundary | Typical treatment |
|---|---|
| Within one availability zone, private addresses | Usually free |
| Between zones in the same region | Often charged, sometimes in both directions |
| Between regions of the same provider | Charged, more than cross zone |
| Out to the public internet | Charged, typically the highest rate |
| To a different provider or on premises | Charged as internet egress unless a dedicated link exists |
Two traps hide in that table. The first is that traffic between zones is charged on some platforms in both directions, so a chatty replication link between two zones bills twice for the same conversation. The second is that using a public address to reach a resource that is physically next door will often route the traffic over the public path and bill it accordingly, even though both ends are in the same data centre. Using private addressing is not just good security practice, it is directly a cost control. The networking baseline guide covers how to set that up so the cheap path is the default path.
Architectures that generate egress without anyone noticing
The expensive patterns share a common feature: the data movement is a side effect of a design decision made for another reason.
Microservices split across zones for redundancy will chat across the zone boundary on every request, and a single user action that touches eight services may cross the boundary several times. Logging and metrics shipped to a third party observability platform is continuous outbound traffic, often at a volume nobody has measured, and it grows with your fleet rather than with your users. A database replica in another region replicates every write forever. Container images pulled from an external registry on every deployment, multiplied by every node in an autoscaling group, is a surprisingly large recurring transfer.
Then there is the simple case of serving large files directly from object storage to end users. Video, software downloads, high resolution imagery and map tiles all have the property that the bytes going out vastly exceed the bytes stored, so the transfer charge can dwarf the storage charge by an order of magnitude or more. For media heavy products this is not a line item, it is the dominant cost of the business.
Content delivery networks change where the meter sits
A CDN caches your content at edge locations and serves repeat requests from there. The effect on your bill is that traffic from your origin drops to roughly one fetch per object per edge per cache lifetime, while the bulk of user traffic is served by the CDN and billed at the CDN’s rate.
Whether that saves money depends on three things. Cache hit ratio is the big one: content that is highly cacheable, like static assets and media, benefits enormously, while personalised API responses benefit very little. The CDN’s own egress rate is the second, and it is usually lower than direct provider egress but not zero. The third is whether your provider discounts or waives origin to CDN transfer, which several do for their own CDN product and not for third party ones.
Measure your hit ratio before and after. A CDN in front of uncacheable content adds a hop, adds a bill, and saves nothing. A CDN in front of a media library can reduce transfer costs dramatically and improve latency at the same time.
Backups, replication and the quiet continuous drain
Backup and disaster recovery traffic has a particular character: it is steady, automated, invisible in application metrics, and it runs whether or not anyone is using the system. Nightly full backups shipped off platform move the entire dataset every night. Continuous replication to a secondary region moves every write. Neither shows up in a conversation about traffic because neither is user traffic.
Three adjustments usually help without weakening the protection. Ship incrementals rather than fulls, with a periodic full to bound the restore chain. Compress before transfer, since most backup payloads compress well and the compute cost is trivial against the transfer cost. And check whether your retention policy requires an off platform copy of everything or only of the data that matters, because teams frequently replicate caches, derived data and rebuildable artefacts alongside the irreplaceable records.
If you deliberately keep a backup copy at a second provider for isolation, which is a sound practice, price the transfer as part of that decision rather than discovering it later. Low cost storage oriented accounts such as Buy Scaleway Account or Buy UpCloud Account are frequently chosen for this, and the Kamatera and UpCloud comparison covers how transfer allowances differ at that tier.
Measuring egress before it becomes a line item
You cannot manage what the invoice only summarises. Every major provider exposes transfer metrics per interface, per load balancer and per storage bucket, and flow logs give you the source and destination detail that explains an anomaly. The work is in turning that into a routine rather than an investigation.
Start by establishing a baseline: gigabytes out per day, broken down by the four boundaries in the table above. Then set an alarm on the daily rate rather than the monthly total, because a replication loop or a runaway retry can move a month of expected traffic in a weekend. Finally, attribute. Flow logs tell you which workload is generating the bytes, and an unattributed transfer charge is one nobody will take responsibility for reducing.
Designing to keep bytes on one side of the boundary
Most egress reduction comes from a handful of decisions rather than from clever optimisation.
Keep components that talk constantly in the same zone, and accept the availability trade deliberately rather than by accident. Use private endpoints for provider services so that traffic to object storage and managed databases stays on the internal network. Compress responses and use efficient serialisation formats, since halving payload size halves this bill directly. Cache aggressively at the edge for anything cacheable. Batch chatty integrations into fewer, larger transfers. And if you serve media at scale, make the delivery path a first class design decision rather than a default.
The strategic version of this question is where the data lives in the first place. A workload whose output is mostly consumed inside the same provider has a very different cost profile from one that pushes bytes to the world, and that difference should influence the choice of platform rather than being discovered after it. If you are at that stage, the provider catalogue is worth reading with transfer allowances specifically in mind, and our guide to moving data between providers covers the one off case of getting it out again.