Something is broken in full stack e-commerce, and I don’t think most dev teams haven even noticed.
The “best practices” we’ve leaned on for the last decade were built for a different web. They were built when monoliths reigned, when requests-per-second looked a lot different, and when scaling meant throwing more hardware at the problem.
But here’s what I’m seeing:
Teams are still optimizing for old assumptions. They’re over-engineering slow frontends, clinging to complex backends, and architecting apps as if we’re still in 2015.
This isn’t just inefficient – it’s dangerous.
The new demands of e-commerce
Let’s be real here: consumer expectations have changed. They don’t just want fast. They want instant. And they want it across every device, on flaky connections, without giving up a seamless experience.
At the same time, infrastructure costs are rising. Shipping code globally isn’t as “cheap” as it once felt. AI-generated traffic, fraud bots, and edge workloads are squeezing margins. And with Google cracking down on core web vitals, your site’s speed now directly impacts discoverability.
The modern stack needs to evolve… urgently.
What’s not working anymore
Let’s break down a few practices that should be on the chopping block:
1. Over-reliance on traditional REST APIs
REST was fine when apps were small and backend complexity was minimal. But the modern e-commerce stack is a constellation of services: CMS, PIM, ERP, checkout engines, loyalty, personalization, and more.
REST leads to over-fetching, under-fetching, and a spaghetti mess of versioning. The move to GraphQL and edge data orchestration isn’t just a trend – it’s a survival strategy.
2. SSR everywhere (without nuance)
A lot of teams embraced server-side rendering as a silver bullet for SEO and speed. But they’re SSR-ing everything, even parts of the site that don’t need it.
This tanks performance, increases server load, and clogs your dev pipeline. The future? Smart rendering strategies such as edge caching and streaming components.
3. Ignoring the edge
Most teams still deploy as if geography doesn’t matter. But latency kills conversion. If you’re not leveraging edge compute to run logic closer to the user (think auth, personalization, pricing, etc.) then you’re leaving revenue on the table.
4. Believing “mobile-first” means “shrink it down”
Mobile-first isn’t just a design strategy, but a performance mandate. You can’t get away with bloated JavaScript bundles and slow TTFB. If your mobile Lighthouse score is sub-70, you’re losing customers every minute.
What to prioritize now
Here’s what forward-thinking teams are focusing on instead:
1. Modular architecture with edge-native thinking
Forget the monolith vs microservices debate. The real win is in modularity, as in, building services that can be selectively deployed, scaled, and cached at the edge.
Platforms like Vercel, Netlify, and Cloudflare aren’t just for hobby projects anymore. They’re becoming the backbone of enterprise-grade commerce.
2. Composable commerce, but with opinionated defaults
“Composable” has become a buzzword, but most teams fail by over-customizing. The ones coming out on top are choosing platforms that are flexible but come with smart defaults (think: Shopify Hydrogen, Medusa, or Fabric).
3. Observability baked into the dev cycle
Speed isn’t just about performance metrics – it’s about developer velocity. Top teams are integrating observability (e.g., LogRocket, Datadog, Highlight) into every deploy. They ship faster and smarter.
4. A shift from performance as a feature to performance as a foundation
This is the big one. Performance isn’t something you sprinkle on at the end. It’s baked into every architectural decision, from bundling to routing to caching.
What this means for you
If you’re leading (or invovled with) an e-commerce dev team, now’s the time to reevaluate your assumptions.
The stack that got you here won’t get you to the next phase.
Start with an audit: What parts of your app are overbuilt? Where are you SSR-ing unnecessarily? How close is your compute to the end user?
You might find that your “best practices” are actually your bottlenecks.
The bottom line
Old advice dies hard, but in tech, clinging to it is a recipe for irrelevance.
The e-com full stack we all used to live by is changing fast. The teams that thrive won’t be the ones with the biggest budgets or most developers. They’ll be the ones who move quickly, embrace simplicity, and architect for the edge-first, speed-first, composability-driven web.
The shift is already happening.
Don’t let your architecture be the reason your business gets left behind.
Until next time.