The re:Invent 2025 Speech We All Heard vs. The Bill We’ll Actually Pay

If you watched Andy Jassy’s keynote at AWS re:Invent 2025, you probably heard a lot about price cuts and competitive positioning. Amazon announced further S3 pricing reductions and rolled out expanded zero-egress agreements with select CDN partners. The message was clear: we’re listening to competitive pressure from Google Cloud and Azure, and we’re doing something about it. The applause was genuine. The relief was palpable.

Here’s the thing nobody wants to admit in a keynote: when you’re running anything resembling a real multi-cloud strategy, those headline wins barely dent your actual egress costs. I’ve been in enough war rooms to know the difference between marketing narratives and what your CFO sees at month-end close. The pricing reductions matter for certain workloads on specific services. But for enterprises actually moving data between cloud providers at scale, the story remains stubbornly unchanged.

This is where the rubber meets the road. And the road is expensive.

The Egress Tax Nobody Negotiates Their Way Out Of

According to Cloudflare’s 2025 Bandwidth Alliance research, enterprises moving significant volumes of data between major cloud providers still face average egress fees in the range of $0.08 to $0.09 per GB for high-volume transfers that fall outside alliance agreements. Let that number sit for a moment. If you’re moving just 10 TB between clouds monthly, you’re looking at roughly $800 to $900 before you even think about ingress costs, storage duplication, or the operational overhead of managing the transfer itself.

The Bandwidth Alliance partnerships help, sure. If you’re using Cloudflare, Fastly, or a handful of other approved partners, you might catch a break. But here’s where it gets real: most enterprises don’t have the traffic patterns that fit neatly into these alliance frameworks. Your workloads are asymmetrical. Your growth is unpredictable. Your compliance requirements push data to specific regions that aren’t covered by the preferred partner list.

I’ve watched teams celebrate landing a 15 percent discount on egress through negotiation, then watch their bill spike 40 percent the following quarter because they launched a new data pipeline nobody had accounted for in the negotiation. The algebra never works the way you hope.

The Maturity Gap Nobody’s Talking About

According to the Flexera 2026 State of the Cloud Report, 89 percent of enterprises have adopted some form of multi-cloud strategy. That number should make you feel less lonely. But then Flexera measured something more useful: only 28 percent of those enterprises report having mature cost governance tools deployed across all their providers. Let that asymmetry sink in.

89 percent minus 28 percent equals organizations flying blind. They have multi-cloud workloads, they have multi-cloud bills, but they don’t have the observability infrastructure to understand which workloads are costing them what, across which providers, in which regions. Gartner’s 2025 Cloud Cost Optimization report estimated that 35 percent of enterprise cloud spend is wasted, with multi-cloud networking costs taking up an increasing slice of that pie.

Egress fees are often the easiest place to hide this waste. They’re commoditized and opaque. They don’t show up in your per-VM cost tracking. They live in a separate line item that most teams never correlate against the business value they generated. By the time you notice it’s a problem, you’ve already shipped the architecture that made it inevitable.

What Google Cloud’s New Cross-Cloud Network Actually Means (and Doesn’t)

Google Cloud announced the Cross-Cloud Network at Google Cloud Next 2025, framing it as a solution to exactly this problem. Simplified inter-cloud connectivity, they promised. Unified networking across your multi-cloud estate. It sounds like exactly what we’ve been waiting for.

Then you read the fine print. The solution requires workloads to run on supported regions within specific Google Cloud proximity, which constrains practical adoption immediately. If your compliance posture requires data residency in regions where Google Cloud doesn’t offer this integration, you’re back where you started. If your AWS workloads are locked into us-east-1 for legacy reasons and your Google workloads need to be in europe-west1, the cross-cloud network becomes a nice feature you can’t actually use.

This isn’t a criticism of Google’s engineering. It’s a recognition that solving the multi-cloud cost and complexity problem at the networking layer requires architectural flexibility that most enterprises simply don’t have. We’re all constrained by history, compliance requirements, and the sunk cost of existing infrastructure.

The Real Lever: Knowing What You’re Actually Moving

If you want to actually move the needle on multi-cloud costs, the solution isn’t waiting for the next re:Invent keynote or the next Google Cloud announcement. It’s deliberately unglamorous: you need comprehensive visibility into what data is moving where, why, and at what cost. You need the kind of observability that lets you correlate egress charges against actual business outcomes.

Start by mapping your data flows. Not your service dependencies, not your architectural diagrams. Your actual data movement. Where is data leaving AWS, when, and how much is it costing you? Same question for Google Cloud, Azure, and wherever else you’re running workloads. You’d be surprised how many teams can’t answer this question with confidence.

Then stress-test your CDN and alliance partnerships. If you’re not sitting at the table understanding exactly which transfers fall inside versus outside your negotiated terms, you’re leaving money on the table. Call your account teams. Ask hard questions. The answer might be that you need to reshuffle your architecture, consolidate providers in specific regions, or invest in different tools. But at least you’ll be making that decision from actual data, not assumption.

The AWS data transfer pricing breakdown is public, and so are the pricing models for other major clouds. The variable isn’t the published prices. It’s that most organizations don’t have the instrumentation to connect their billing data to their actual workloads.

The real cost of multi-cloud in 2026 isn’t the egress fees themselves. It’s the absence of visibility that makes you unable to optimize them away. That’s a solvable problem. It just requires patience, systematic thinking, and the willingness to look at data that nobody wants to present at an all-hands meeting. Which, if you’re reading this, is probably familiar territory already.

If you’ve tackled this in your own infrastructure, or found clever ways to navigate the egress tax that actually worked, I’d genuinely like to hear about it. Drop a note in the comments or reach out. The gap between how this stuff is presented and how it actually works in production is where the interesting conversations happen.

The Pricing Theater We Just Witnessed

Last December at AWS re:Invent 2025, Andy Jassy stood on stage and announced S3 pricing reductions alongside new zero-egress agreements with select CDN partners. The room erupted. LinkedIn immediately flooded with posts about cost savings and strategic flexibility. I watched the keynote with the expression of someone who has stared at a million-dollar cloud bill at 2 AM and knows better than to trust a press release.

Here is what actually happened: AWS responded to genuine competitive pressure from Google Cloud and Azure by making their pricing marginally more attractive in very specific scenarios. The zero-egress partnerships are real, but they work only if you already operate within their approved network boundaries. For the 89% of enterprises currently running a multi-cloud strategy, according to the Flexera 2026 State of the Cloud Report, this announcement solved approximately nothing.

The real story is not the pricing cuts. The real story is that most organizations announcing multi-cloud adoption have almost no visibility into what that adoption actually costs them across all three major providers simultaneously.

Why Your Egress Bills Still Look Like Ransom Notes

Cloudflare published their 2025 Bandwidth Alliance data, and it contains the kind of detail that should keep every infrastructure team up at night. Outside of formal alliance agreements, enterprises still encounter egress fees ranging from $0.08 to $0.09 per GB for high-volume transfers between cloud providers. That is not a typo. That is the actual price you pay when you move data out of one cloud and into another at scale.

To make that concrete: if you are migrating a petabyte of customer data from AWS to Google Cloud, you are looking at roughly $80,000 to $90,000 in transfer costs alone. The alliance agreements help, but they require specific architectural decisions and commitment to particular CDN partners. Most organizations discover this bill exists only after they have already made their egress decision.

I have watched senior architects describe multi-cloud as a cost optimization strategy while their actual data movement costs climb into six figures. The gap between intention and reality here is not a rounding error. It is a structural problem in how we provision and manage distributed workloads.

The Governance Maturity Crisis Nobody Talks About

Gartner’s 2025 Cloud Cost Optimization report landed with a quiet thud that should have been louder: 35% of enterprise cloud spending is simply wasted. Not poorly optimized. Wasted. And the share of that waste attributable to multi-cloud networking costs keeps climbing as more organizations chase distributed architecture without the operational tools to manage it.

Here is the uncomfortable truth buried in the Flexera data: 89% of enterprises claim a multi-cloud strategy, but only 28% report having mature cost governance tools that work across all their providers. Three out of four organizations running workloads on multiple clouds have basically no unified cost visibility. They are making egress and routing decisions in the dark.

I have spent enough time in cloud cost management to know what this actually looks like in practice. A team provisions workloads in three regions across two providers. They implement monitoring in each cloud’s native console. When the quarterly bill arrives, nobody can explain why data movement costs tripled. Everyone suspects misconfiguration. Nobody can prove it because the audit trail lives in three separate dashboards that do not talk to each other.

The career lesson here matters: if you are building infrastructure in 2026 and your organization lacks unified cost governance, you have a very short window to either fix that or your name will be attached to some truly spectacular waste.

Google Cloud’s Elegant Promise and Brutal Reality

Google Cloud announced Cross-Cloud Network at Google Cloud Next 2025 with genuine technical elegance. The concept is sound: simplified inter-cloud connectivity with built-in optimization. The execution has a problem. It requires workloads to run on supported regions, and those supported regions do not include most of the places enterprises actually run production code.

This is not incompetence. This is the fundamental tension in building multi-cloud solutions: the technical elegance of a unified approach collides with the messiness of actual enterprise infrastructure. Organizations have workloads in AWS regions that do not have Google Cloud equivalents. They have Azure services that do not exist in Google Cloud. They have legacy infrastructure that predates all three providers.

The result is that Cross-Cloud Network becomes another specialized tool for specialized scenarios rather than a general solution to the multi-cloud problem. It works beautifully if your architecture fits its assumptions. If your architecture is anything like the actual enterprises I work with, you will use it for 15% of your traffic and pay standard egress rates for the rest.

What This Means for Your Career in 2026

The engineers who will be most valuable over the next two years are not the ones chasing the latest multi-cloud announcements. They are the ones who understand the actual financial mechanics of distributed workloads and can speak authoritatively about why a proposal either makes sense or generates unnecessary cost.

Start auditing your current setup. Pull your actual egress costs from the last twelve months. Compare them against your business justification for multi-cloud. If you cannot articulate a clear reason why the data movement costs are worth the architectural benefits, you have a conversation to start with your leadership.

Implement unified cost governance before you add another cloud provider. This is not optional. The AWS data transfer pricing breakdown alone contains enough complexity that you need tooling and process, not spreadsheets and hope.

The multi-cloud strategy that works in 2026 is not the one that sounds the most flexible. It is the one where someone has actually done the math and made a deliberate decision about which workloads go where and why. If that someone is you, and you can show the work, you are in a good spot.

The Setup: Why I Spent Six Months Testing Both

I’ve been writing code for long enough to remember when autocomplete was considered witchcraft. I’ve also been around long enough to watch every new productivity tool arrive with evangelical fervor, only to watch it become either a footnote or genuinely useful infrastructure. So when the AI coding assistant space started bifurcating in late 2024, I did what any self-respecting engineer would do: I decided to run a proper experiment instead of relying on hot takes from people who have skin in the game.

The catalyst was watching Cursor cross 500,000 paying subscribers by mid-2025, which is honestly remarkable velocity for a developer tool. That matters not because subscriber count determines quality, but because it signals real adoption among working engineers who are literally paying money from their own pockets or their employer’s budget. Meanwhile, GitHub Copilot was consolidating its position with 1.8 million paid subscribers by the end of 2024 and had just rolled out multi-model support, letting users swap between GPT-4o, Claude 3.5 Sonnet, and Gemini 1.5 Pro depending on the task. The strategic divergence was interesting. Copilot was broadening its foundation models. Cursor was going deeper on the IDE experience.

I set ground rules: daily use in production contexts, no artificial constraints, honest tracking of actual time saved versus perceived time saved. Production code, real deadlines, the whole deal. Six months later, I have thoughts that refuse to fit neatly into any existing narrative.

What These Tools Actually Do (And Don’t)

Let’s start with the unsexy truth that most benchmarks bury: both tools are legitimately good at specific tasks and genuinely mediocre at others. Neither one is some universal problem-solver that makes you a 10x engineer. The Stack Overflow Developer Survey 2025 found that 62 percent of developers using AI coding tools report spending less time on boilerplate work but see no significant reduction in debugging time. That number should matter to you. It means these tools are doing exactly what they’re advertised to do: accelerating routine pattern-matching, not making you fundamentally smarter about architectural problems or subtle logic errors.

Copilot, with its multi-model architecture, excels at code generation velocity. When I’m building a REST endpoint for the fifteenth time this month, or wiring up yet another authentication flow that follows established patterns, Copilot gets out of my way fastest. You feed it some context, it generates something in the right ballpark, you tweak it, you move on. The model switching is genuinely useful: sometimes Claude is better at documentation and context-heavy refactoring, sometimes GPT-4o is sharper on mathematical logic, sometimes Gemini catches something weird about performance implications. This flexibility matters more than you’d think until you’re in the middle of a specific task and realize the default model isn’t pulling its weight.

Cursor takes a different philosophical angle. It’s built on a fork of VS Code, which means it inherits all the IDE niceties you’re already accustomed to, and it layers Agent mode on top. That autonomy layer can be genuinely spooky when it works. Having an AI that can open files, read errors, edit multiple locations, and run terminal commands in a coherent sequence does save time. But here’s where things get interesting in a way the marketing never quite admits.

The Hidden Cost of Confidence

Cursor’s Agent mode represents something new in the developer tool landscape: the ability to introduce what I’ll call “confident but wrong” errors at scale. A JetBrains developer productivity study flagged this exact phenomenon. When an agent autonomously makes changes across multiple files and runs commands, it’s operating with more agency than a code suggestion. Mistakes don’t surface as “here’s something to consider,” they surface as already-committed changes in your working directory. I’ve had Agent mode fix a bug in one place while breaking something subtly in another because it didn’t have deep enough context about a business rule three layers of abstraction away.

The troubling part: these errors are harder to catch in code review. A human reviewer sees a change and assumes the engineer understood the full context. When an agent makes that change, the engineer might not have thought through all the implications because the cognitive load shifted from “generate the right solution” to “verify this reasonable-looking solution.” I found myself reviewing Agent mode output more carefully than I review my own code, which is the opposite of how these tools are supposed to work.

Copilot doesn’t have this problem because it doesn’t have Agent mode. It generates suggestions, you evaluate them, you decide. The cognition stays on you, which is safer. It’s also slower. There’s a trade-off baked into that design philosophy that nobody talks about loudly.

Integration Beats Replacement: What the Data Actually Shows

The JetBrains State of Developer Ecosystem 2025 report includes a datapoint that should reshape how you think about this entire category: 74 percent of developers still prefer their primary IDE over standalone AI coding tools. Seventy-four percent. That’s not “most developers.” That’s supermajority territory. And it tells you something important about the market that neither Cursor nor Copilot particularly wants to advertise.

The future doesn’t look like developers migrating to Cursor as their main development environment. It looks like AI coding capabilities getting baked deeper into the IDEs they already use every day. JetBrains has its own AI features now. Visual Studio has Copilot integration. The trajectory is integration, not replacement. Cursor succeeds not because it’s better than VS Code at being VS Code (it isn’t), but because it’s a clean slate where the AI layer is first-class rather than bolted on. That advantage is temporary, though. Once the entrenched players decide to match that native integration quality, Cursor’s positioning becomes less defensible.

This doesn’t mean Cursor will fail. It means Cursor needs to win on something other than “VS Code but with AI built in.” Right now, that something is primarily the Agent mode and the quality of its foundational model interactions. Whether that’s enough long-term is genuinely uncertain.

The Real Difference: Workflows and Temperament

After six months, here’s what actually matters: Copilot rewards you for having strong domain knowledge already. It works best when you know what you want to build and need help expressing it quickly. It’s a productivity multiplier for competent work. Cursor wants to give you more agency through automation, which is appealing until you realize that agency can create blind spots.

I use both. Copilot integrated into my JetBrains IDE handles most daily tasks. Cursor handles greenfield projects where I’m willing to let the agent make autonomous changes because the risk surface is smaller. I don’t believe in monoculture. The tools are different enough that they have different use cases, and pretending otherwise is just tribalism with better PR.

The honest assessment: Cursor is an impressive product that’s executing well and found real product-market fit. Copilot is more mature, more flexible, and less likely to introduce categories of errors you haven’t optimized for yet. Neither one is the future of development. They’re interim steps toward genuinely integrated AI that doesn’t require switching contexts or worrying about whether an agent is making assumptions that will cause pain later.

If you’re sitting on the fence about trying one, don’t overthink it. The subscription costs are low enough that six months of honest experimentation will teach you more than any article. What specific workflows does your day actually contain? Use that as your north star, not the feature counts or the subscriber numbers. And if you land on strong opinions either way, I’d genuinely like to hear what you’re seeing in your own work.