Several projects we've delivered this year - marketing sites, documentation portals, a couple of smaller e-commerce storefronts - have used a JAMstack architecture instead of the traditional server-rendered stack we'd have reached for a few years ago. JAM stands for JavaScript, APIs, and Markup, and the core idea is straightforward: pre-build the HTML at deploy time rather than generating it fresh on every single request.
What actually changes
In a traditional WordPress or Rails setup, a server assembles the page from a database on every visit. In a JAMstack setup, a static site generator builds every page once, during deployment:
# A typical build step
npm run build
# outputs a folder of plain HTML, CSS and JS - no server-side rendering needed per request
Those pre-built files get served from a CDN, which means a visitor in Dhaka and a visitor in Toronto both get a file served from a nearby edge node, not a round trip to one origin server running application code.
Dynamic features don't disappear - they move
The obvious question is what happens to anything genuinely dynamic: a contact form, user accounts, a shopping cart. The answer is that logic moves out to APIs, often third-party ones, called from client-side JavaScript:
fetch('https://api.forms-service.example/submit', {
method: 'POST',
body: JSON.stringify(formData),
});
A form submission service handles the form. A headless commerce API handles the cart. Authentication is handled by a dedicated identity provider. The static site itself stays static; the dynamic pieces are composed in as separate, independently scaling services.
Why this has been worth the change for us
Three practical reasons. First, security: a site with no database and no server-side application code to exploit has a dramatically smaller attack surface - there's simply less there to compromise. Second, speed: pre-built files served from a CDN edge are close to the fastest thing the web can serve. Third, and the one clients notice fastest: hosting cost, since serving static files is far cheaper than running an always-on application server for traffic that mostly doesn't need one.
The fastest page to serve is the one you already built, sitting on a CDN, waiting.
Where it isn't the right fit
Highly personalised, per-user content rendered fresh on every request - a logged-in dashboard showing live account data - still often makes more sense server-rendered. JAMstack has been the right call for marketing sites, blogs, documentation and storefronts with mostly-shared content; it hasn't replaced every kind of backend, and it isn't trying to.
JavaScript, APIs, Markup - decoupled by design
The core idea is pre-rendering markup at build time rather than on every request, then enhancing it with JavaScript that talks to APIs for anything dynamic. That decoupling is what makes JAMstack sites fast and resilient - there's no server-side rendering pipeline that can go down under load, because most of the page is already a static file served from a CDN.
// Build time: fetch content, generate static HTML
// Runtime: static HTML + client-side JS hitting APIs for dynamic bits
Where the architecture shows its limits
Highly personalized, per-user content - a logged-in dashboard, a live inventory count - doesn't fit the "pre-render once, serve to everyone" model cleanly, which is why the ecosystem has since grown incremental static regeneration and server components to fill that gap. JAMstack was never really "no server," just "server work moved earlier and cached aggressively" - understanding that framing avoids a lot of confusion about what it can and can't do well.