Two articles hit my feed this week that got me thinking: Simon Willison's piece on delivering proven code, and a DEV post about losing our software manners. Both are right about developers getting lazy. But they're missing something critical.
The real constraint isn't ethics or professionalism. It's your bank account.
The Reality Check
I run FPL Hub, a Fantasy Premier League platform serving 2,000+ users with 500K+ API calls daily. When I started, I built it like most developers do—grab whatever frameworks feel good, pull in dependencies freely, ship it and scale later.
Then I got the first Cloudflare Workers bill.
Every millisecond of CPU time costs money. Every wasted loop, every unnecessary dependency, every bloated response—I paid for it. Not my company's AWS account with unlimited budget. My actual money.
That's when I learned what no bootcamp or tutorial ever taught me: waste has a price tag.
The Missing Piece
Simon talks about proving your code works. Daniel talks about the discipline we lost when hardware got cheap. Both appeal to being a good engineer.
But here's what changed my behavior: I couldn't afford to be wasteful.
Edge computing platforms like Cloudflare Workers, AWS Lambda, and Vercel Functions reintroduced constraints through economics:
- Pay per request
- Pay per millisecond
- Pay per GB transferred
- Hard CPU limits
- Tight memory constraints
Suddenly, that 50MB dependency for a simple utility function isn't just "bad practice"—it's costing you money on every cold start.
What 500K Daily Calls Taught Me
Before edge computing:
- Pulled in entire libraries for single functions
- Didn't worry about response sizes
- "It works" was good enough
- Tests were optional (until production broke)
After Cloudflare started billing me:
- Every dependency justified
- Response payloads measured in KB
- Performance profiling became mandatory
- Tests became insurance against expensive bugs
The 99.9% uptime I maintain isn't because I'm naturally disciplined. It's because downtime and inefficiency directly hit my margins.
The Broader Context
Stack Overflow's 2025 survey shows 92% of developers now use AI coding tools. That's great for velocity. But most of these tools generate code optimized for "working," not for "efficient."
I've seen it on Upwork as a freelancer. Developers dump AI-generated Next.js apps that consume 2GB RAM to show a form. It "works." But run that on a platform with real constraints and you'll burn through your budget in days.
Meanwhile, startups in Nigeria (where I'm based) and across emerging markets can't afford AWS bills that assume infinite resources. We need software that's efficient by default, not by exception.
Edge Computing as the New Constraint
This isn't about going back to 1995 and programming like we have 4MB of RAM. It's about modern platforms reintroducing the economic forcing function that makes efficiency matter:
Cloudflare Workers:
- 128MB memory limit
- 50ms CPU time (free tier)
- Pay per request after free tier
- Forces you to optimize or go broke
AWS Lambda:
- Pay per GB-second
- Cold start costs
- Every inefficiency visible in your bill
Vercel Edge Functions:
- Similar constraints
- Performance is directly tied to cost
These platforms make waste expensive again. Not in abstract "bad practice" terms, but in actual dollar leaving your account.
What This Means For You
If you're building with AI tools, ask yourself:
-
Can this code run profitably at scale?
- Not "does it work?"
- Not even "is it maintainable?"
- But: "Can I afford to run this?"
-
What's the cost per request?
- If you don't know, you're probably overspending
- Edge platforms make this transparent
-
Is this dependency worth its weight?
- That 50MB library costs you on every cold start
- Tree-shaking isn't enough—start with less
The Future Is Constrained (Again)
The developers winning in 2025 aren't the ones generating the most code. They're the ones building systems that are:
- Efficient enough to run profitably
- Lean enough to deploy globally
- Fast enough to compete
Edge computing isn't just a deployment target. It's a forcing function that brings back the discipline we lost when "just add more RAM" became the default answer.
My VPN-Workers project (targeting Nigerian users where bandwidth is expensive) would be impossible with bloated traditional architecture. But on Cloudflare Workers, where every byte and millisecond is accounted for, it's not just possible—it's profitable.
The Bottom Line
We didn't lose our software manners because we're lazy. We lost them because nothing punished waste.
Edge computing brings back consequences. Not through shame or ethics, but through your P&L statement.
And honestly? That's the constraint that actually changes behavior.
What's your experience with serverless costs? Are economic constraints making you a better developer, or just adding stress? Drop your thoughts below.
Top comments (0)