Egress: Watching the Traffic That Costs You Money
Somewhere in your future — if it has not happened already — is an invoice with a networking line item nobody can explain. Not compute, not storage: data transfer. It will be larger than last month's. Nobody will remember changing anything. And you will be the person asked to find out where the money went. This guide exists so that when that day comes, you already have the graphs.
The root of it is a billing asymmetry that every cloud shares and no on-prem experience prepares you for. Traffic into the cloud is generally free, and traffic out of it is billed by volume. On-prem, you paid for a circuit and used it however you liked; moving a terabyte across your own WAN cost electricity and patience. In the cloud, the meter runs on the exit, and it runs silently — there is no error, no alert, no performance symptom. Egress that costs a fortune feels exactly like egress that costs nothing.
Which makes this a monitoring problem, and a very winnable one. By the end of this guide you will know where surprise egress comes from and how to measure outbound traffic by source. You will know how to baseline what normal looks like. And you will know how to catch a step-change in days instead of discovering it at the end of the billing cycle. No prices appear anywhere here. Rates differ by provider, by region, and by the phase of the moon, and they change. The patterns are what stay true.
In this guide
- The billing asymmetry in plain words
- Where surprise egress comes from
- Measuring egress by source
- Baselining normal
- Alerting before the invoice does
- Architecture patterns that reduce egress
- The monthly egress review ritual
- Where to go next
The billing asymmetry in plain words
Think of the cloud as a hotel with free check-in and a metered exit door. Bringing data in costs nothing — providers are delighted to receive your backups, your datasets, your entire digital life. Data leaving is charged per unit of volume, every gigabyte, every time. The cynical reading is that the asymmetry discourages leaving; the operational reading is simpler. You need to know what walks out of the building, because each departure has a price on it.
The exit door is not one door, and the tiers matter. Here is the general pattern, from most expensive to free. Traffic to the internet is the headline rate. Traffic between regions (the provider's geographically separate campuses) is billed, usually less than internet rates. Traffic between availability zones within a region is often billed too, at a small rate that quietly matters for chatty systems. Traffic within a single zone using private addresses is typically free. On top of this, some managed doors — NAT gateways especially — meter the volume they process as well. So a byte can be paid for once for processing and again for leaving. None of the specific rates matter for our purposes; the shape does. Every design decision that moves traffic down that ladder — internet to cross-region, cross-region to cross-zone, cross-zone to same-zone — moves it toward free.
One more asymmetry worth naming: the feedback loop. Most costs in IT announce themselves — a full disk alerts, an oversized instance shows idle CPU. Egress has no gauge on by default and no consequence until the invoice. The invoice arrives with a delay measured in weeks and a resolution measured in totals. The invoice is, in effect, a monitoring system with a polling interval of one month and no thresholds. Your job in the rest of this guide is to build a faster one.
And to be fair to the model for one sentence: metered egress is also why you never think about the provider's internet capacity, peering, or transit contracts — that is all bundled into the rate. You traded a circuit you managed for a meter you must watch. The trade is fine; the watching is the part this guide is for.
Where surprise egress comes from
Surprise egress is rarely exotic. It is almost always a reasonable-sounding thing, doing exactly what it was configured to do, by someone who did not know the meter existed. The usual suspects:
- Backups pulled down to on-prem. The classic. A backup job in the cloud copies nightly fulls back to the building for safekeeping. That is a genuinely sensible practice with a per-gigabyte toll on every run. Full copies nightly where incrementals would do can multiply the cost several times over for the same protection.
- Replication between regions. Databases, storage, and disaster-recovery tooling happily mirror every write to a second region. The first sync is big; the steady drip afterward is forever. Replication is often the right call — it should just be a decision, not a default nobody remembers accepting.
- A service accidentally serving the internet. A misconfigured application or a publicly readable storage area starts handing out large files — media, installers, datasets — to the whole world. Popularity you did not plan for becomes a bill you did not plan for. And hot-linked files are the internet's way of letting you sponsor a stranger's website.
- Chatty agents phoning home. Monitoring, security, and inventory agents that report from every instance to an outside service. Each heartbeat is tiny. A fleet of instances reporting frequently, forever, adds up to a steady outbound hum. And telemetry defaults are rarely tuned with the meter in mind.
- Logs and metrics shipped out. Sending every log line to an external analytics service means your observability becomes a top talker. The more verbose the logging, the bigger the toll — debug-level logging left on after an incident is a classic slow leak.
- Traffic taking the scenic route. Two instances exchanging data via public addresses when a private path exists, or chatty tiers split across zones for no articulated reason. Same conversation, pricier road.
- People, repeatedly. A developer pulling a production dataset down to a laptop for testing, every morning, because it is convenient. An analyst exporting the same large report to an outside tool daily. Individually defensible, collectively a pattern — and nobody involved has any reason to suspect it costs anything, because on-prem it never did.
Notice the theme: none of these are failures. Everything is working. That is exactly why only measurement catches them.
Measuring egress by source
You have two complementary instruments, both covered in depth elsewhere in this pillar. One is flow logs, which attribute traffic to specific sources and destinations. The other is provider metrics, which give cheap, always-on totals per instance and per gateway. The metrics tell you that outbound volume changed; the flow logs tell you who did it.
The core flow-log move is a filter and a sum. Select flows whose destination lies outside your own private address ranges — those are the ones headed for the exit. Then total the bytes by source address. Conceptually:
flows where dstaddr not in (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) sum bytes group by srcaddr sort descending srcaddr outbound bytes owner (from your inventory) 10.0.2.31 1.9 TB backup server 10.0.1.25 120 GB app server — external APIs 10.0.1.44 60 GB web tier — responses to users
Three refinements make this genuinely useful. First, separate the internet exit from the hybrid exit. Traffic to your building's ranges over the VPN or interconnect is egress too, billed under its own pattern. Lumping it in with internet egress hides both stories. Second, group by destination as well as source. "Who are we sending to?" catches the hot-linked-files case, where the surprising part is thousands of unfamiliar destinations. Third, join the top sources against your inventory so the report says backup server instead of a bare address. The difference decides whether the report gets read.
From the metrics side, watch the doors themselves: bytes out at the NAT gateway, the internet-facing load balancer, and the hybrid connection. Per-instance bytes-out metrics are useful but need care. They count all traffic leaving the instance, including free same-zone chatter to the database next door. So treat them as a pointer toward which machines are busy. Let flow logs assign the blame for what actually crossed a billed boundary.
Two bookkeeping habits multiply the value of all of this. Label your resources by service and owner — most providers support tags or labels. Then sums can be grouped by "what this is for" rather than by address. And the egress report reads like an org chart instead of a phone book. And keep the aggregation queries saved and named where the whole team can run them. The measurement that only one person knows how to produce is a measurement that stops happening the week that person is on holiday.
Baselining normal
A number is only a surprise if you know what it usually is. Baselining egress means graphing outbound volume per boundary — internet, cross-region, cross-zone if it is material, and the hybrid link. It means letting a few weeks of history teach you the shape. Most environments settle into a recognizable rhythm. There is a business-hours hump from user-facing traffic, a nightly spike from backups, and a weekly bulge from batch jobs. There is also a floor of agent hum that never quite reaches zero.
Learn three numbers for each boundary: the typical daily total, the size and timing of the routine peaks, and the floor. Each has its own use. The daily total is what you will alert on. The peaks tell you whether a spike is "the backup, as scheduled" or news. And the floor is the most underrated of the three: overnight outbound volume on a system with no overnight users is pure overhead. And a floor that quietly doubles is how slow leaks — a new agent, chattier logging, a replication change — announce themselves to anyone who is looking.
Mind your units while you do this. Network people think in megabits per second; the bill thinks in gigabytes per month. Both describe the same traffic, and converting between them is worth doing once, on paper, for your own environment. A modest-looking sustained flow adds up to a startling monthly total, which is precisely why slow leaks are so effective. Baseline in the bill's units (volume per day per boundary) and keep the rate-based graphs for diagnosing when in the day the volume moves.
Tip: annotate your egress graphs with deploy dates and configuration changes, even if the annotation is just a line in a text file. Egress step-changes are almost always caused by a human action taken days before anyone looks at the graph. The annotation turns "what on earth happened around the middle of the month?" into "oh — that is the day we enabled the new log shipper."
Alerting before the invoice does
The invoice alerts you monthly, in arrears, in currency. Your monitoring should alert you in days, in gigabytes, while the cause is still fresh in somebody's memory. Three rules cover most of the risk:
- 1. A step-change rule per boundary. Compare each day's outbound total against the trailing baseline; alert when it jumps by more than your chosen multiple and stays there. A single odd day is a curiosity; two or three in a row is a new normal being born, and you want to meet it early.
- 2. A new-top-talker rule. Alert when an instance that has never appeared near the top of the egress report suddenly does. New name in the top five means new behavior somewhere — the report should introduce you before the invoice does.
- 3. The provider's spending alerts as backstop. Most providers let you set budget alarms that fire when accumulating charges pass thresholds. Set them — they are free insurance — but treat them as the smoke alarm, not the monitoring. By the time a monthly budget threshold trips, the gigabytes are long gone; your traffic graphs are where the story is still actionable.
Route these like real alerts — into the same queue and escalation as everything else, per the one-view argument in the provider metrics guide. A cost anomaly report that lands in a mailbox nobody owns is just a slower invoice.
And calibrate the urgency honestly. An egress step-change is almost never a middle-of-the-night page; it is a next-business-day conversation. The exception is the misconfigured-public-service case. Outbound volume to the internet from something that should not serve the internet can also be a security story — data leaving that nobody sent. If a step-change alert points at an unfamiliar destination pattern rather than a familiar job running larger, treat it with incident seriousness first and cost curiosity second.
Architecture patterns that reduce egress
Monitoring finds the traffic; architecture shrinks it. These patterns are generic, provider-neutral, and each comes with an honest tradeoff:
| Pattern | What it does | The honest tradeoff |
|---|---|---|
| Keep chatty pairs in the same zone | Moves app-to-database chatter onto the free tier of the ladder | Less resilience — a zone failure takes both; reserve cross-zone spend for the paths that earn it |
| Cache at the edge | A content delivery layer serves repeat downloads near users, so popular files exit once, not once per viewer | Cache invalidation is famously one of the hard problems; stale content is the failure mode |
| Compress before transfer | Backups, logs, and replication streams shrink substantially for compressible data | Costs CPU on both ends, and already-compressed media barely shrinks |
| Ship deltas, not fulls | Incremental backup and replication move only what changed | Restores get more complex; test them, or the savings were rented, not owned |
| Use private paths to provider services | Private endpoints keep storage and API traffic off the metered NAT path | More configuration to manage; each endpoint is one more thing with a name |
| Move the code, not the data | Run analysis where the data lives and send home the small results, not the raw terabytes | Sometimes the tooling genuinely lives elsewhere; then the data must travel, and the meter is the cost of that choice |
The meta-pattern behind all six: egress cost is mostly decided at design time, quietly, by whoever chose where things live and what talks to what. Monitoring's job is to make those decisions visible while they are still cheap to revisit.
The monthly egress review ritual
Fifteen minutes, once a month, ideally a few days after the invoice arrives so you can reconcile against it. The ritual:
- 1. Pull last month's outbound totals per boundary — internet, cross-region, cross-zone, hybrid — and set them beside the previous few months. Trend, not snapshot.
- 2. Reconcile roughly against the invoice's transfer lines. You are not doing accounting; you are checking that your instruments and their meter tell the same story. A large disagreement means a boundary you are not measuring.
- 3. List the top ten egress sources and require a one-line explanation for each. "Backup server, nightly incrementals, expected" is a fine answer. No answer is the finding.
- 4. Compare the overnight floor with last month's. Slow leaks live here.
- 5. Ask what changed: new services, new agents, new replication, logging levels. Cross-check against your annotations.
- 6. Hunt one orphan. Somewhere there is usually a forgotten thing still faithfully transferring. It might be a replication target for a project that ended or a test environment still shipping logs. It might be a snapshot job copying to a region nobody uses. The review is the natural moment to retire one.
- 7. File one improvement if one is warranted — a compression flag, a scope change, a chatty pair rehomed. In that case, write down what you expect next month's number to be. The written expectation is what turns next month's review from vibes into a check.
The ritual's real product is not the savings, though there will be some. It is that "how much do we send out, and why?" becomes a question your team can answer in one breath. That is exactly the posture that makes the surprise invoice impossible.
Where to go next
Egress is the one part of networking where the graph has a currency axis. It rewards exactly the habits you already have: measure, baseline, alert on change, review on a rhythm. Instrument the exits with flow logs and gateway metrics. Learn your shape, and let step-change alerts — not the invoice — be how you find out something new started talking. The rest of the Cloud Network Monitoring pillar surrounds this guide. It covers flow logs for the attribution engine and provider metrics for the always-on totals. It also covers hybrid path health for the private exit your backups ride home on.
Put this into practice with SysPeep Monitor
A good share of cloud egress lands somewhere very familiar: on the WAN link into your own building. SysPeep Monitor graphs that link's utilization alongside everything else it watches. That includes auto-discovered devices, SNMP and WMI health checks, thresholds and alerts from one web console. So the on-prem end of every big transfer shows up in the same place as the rest of your network's story. The free trial installs on any Windows machine.
Download Free TrialLearn About SysPeep