MERN gets a reputation for falling apart at scale. In practice, it is almost never the stack that fails — it is a handful of early decisions that were convenient at 100 users and structurally wrong at 100,000. Here are the patterns that survive that transition.
1. Model MongoDB around reads, not around entities
The most common mistake is designing collections as if they were normalized SQL tables, then discovering that every page load needs four $lookup stages. MongoDB rewards you for storing data the way you read it.
- Embed what is always read together and rarely written independently — an order and its line items.
- Reference what grows without bound or is shared — a user, a product catalog entry.
- Duplicate small display fields (author name, product title) deliberately, and update them through a single write path.
- Index for your actual query shapes, including sort order. A compound index that ignores the sort field will still hit an in-memory sort.
2. Give Express three layers, not one
Routes that contain business logic, database calls, and response formatting all at once are readable for about six months. The split that keeps paying off is route → service → repository: the route handles HTTP, the service holds business rules, the repository owns queries.
// routes/orders.js — HTTP only
router.post("/", validate(createOrderSchema), async (req, res, next) => {
try {
const order = await orderService.create(req.user.id, req.body);
res.status(201).json(order);
} catch (err) {
next(err); // ek centralized error handler
}
});The payoff is testability. Business rules can be tested without spinning up HTTP, and queries can be swapped or cached without touching the rules.
3. Draw hard state boundaries in React
Most React performance problems are state placement problems. Server data does not belong in the same store as UI state, and neither belongs in a single global context that re-renders half the tree.
- Server state — cached, keyed, and invalidated by a data layer (React Query, SWR, or RSC + revalidation).
- URL state — filters, tabs, and pagination live in the query string so they are shareable and survive refresh.
- Local UI state — modals, hovers, and inputs stay in the component that owns them.
- Global state — auth and theme. Almost nothing else earns a place here.
4. Treat Node.js as single-threaded, because it is
One synchronous 400ms loop blocks every request on that process. Run one worker per CPU core behind a process manager, push CPU-heavy work (PDF generation, image processing, report aggregation) to a queue, and keep the request path doing nothing but I/O.
If a request handler is doing real computation, it is already the wrong place for that work.
5. Make failure observable before it is urgent
Structured logs with a request ID, a slow-query log on MongoDB, latency percentiles instead of averages, and an alert on p95 rather than uptime. The teams that scale calmly are the ones who can answer 'what changed' in two minutes instead of two hours.
None of these patterns are exotic. They are just the decisions that are cheap to make on day one and expensive to retrofit on day four hundred.