“Jamstack allows developers to decouple the web presentation layer from the backend logic”
We spoke with Matt Biilmann, CEO and co-founder of Netlify about Jamstack and why it is such a strong stack for the serverless model. Discover what some of the current challenges are for serverless models, how to overcome them, and see what the future holds.
JAXenter: You’ve been talking about Jamstack for a long time now, what makes it such a strong stack for the serverless model?
Matt Biilmann: From the onset, Jamstack represented an approach to web development where the traditional concept of “my server” went away and where the stack moved up a level. When serverless functions started emerging, they instantly felt like a really compelling part of the Jamstack, since they embodied the same shift in the level of abstraction, from working with servers, Linux distributions, system packages, etc, to just writing code and then having it run.
Jamstack allows developers to decouple the web presentation layer from the backend logic, and often this logic becomes a great fit for a serverless approach.
The vision of Jamstack has always been to pre-render whatever you can and then pull any dynamic data that you need. One of the core tenets of Jamstack is the use of reusable APIs, which can just as easily be a serverless function written as an API endpoint. That means a frontend developer can now create more of the experience and easily call on backend services without coordinating across DevOps and backend teams or provisioning servers and APIs.
Most importantly, Jamstack platforms like Netlify allow you to bring the complete development workflow together in one place—where the entire app, including serverless capabilities, can be managed and deployed from a single Git repo.
Jamstack and serverless share the idea that developers should be able to focus on building experiences without having to worry about operations and infrastructure provisioning. Both start with the emphasis on developer experience and developer productivity which make the two natural companions. When managed from a single platform like Netlify, it means that you can apply a frontend workflow to everything, using advanced features like instant rollbacks, easily shareable previews, split testing, and more across both the front-end and serverless backend parts of your app.
Jamstack takes a huge leap forward in speed. There’s almost no latency in the web experience because the heavy lifting happens when the app deploys – when it’s actually compiled and distributed to the network edge.
JAXenter: Is the use of Jamstack still becoming more widespread as we see more cloud transformations happening out of necessity because of the pandemic?
Matt Biilmann: Yes – we’ve seen a big acceleration in digital transformation projects and just more attention to delivering a dynamic and performant web experience. The pandemic moved face-to-face interactions online faster than anyone could have predicted, making Jamstack an even more compelling case for development teams.
Jamstack takes a huge leap forward in speed. There’s almost no latency in the web experience because the heavy lifting happens when the app deploys – when it’s actually compiled and distributed to the network edge. From the users’ perspective, the web app loads instantly because it’s served right from the network edge, without having to render everything on the fly each time, which is the case in a non-Jamstack environment. And of course, faster sites and web apps mean a more competitive experience, improved conversion for e-commerce, higher SEO performance, and so on.
Jamstack is also a far more secure approach to the web. Because you’re removing the dedicated web server as a vector for attack, the surface area for threats is dramatically reduced, meaning that a developer can focus on iterating the web experience and not chasing the latest security issue.
Scaling is also much easier and less expensive with Jamstack which is incredibly important as people move online for more things. In this case, the web frontend lives right at the network edge across many global locations and can elastically scale to accommodate traffic spikes. No capacity planning needed.
Finally, it frees developers to work even faster and use more modern tooling because now frontend development is independent of the backend infrastructure.
In the context of the pandemic, headless commerce is one good example of a Jamstack approach to address the skyrocketing demand for online shopping. “Headless” refers to the approach of decoupling the data and underlying functionality from the frontend UI. It’s really freed up development teams to move faster and ship more engaging and personalized shopping experiences. Experiences that drive traffic and convert at a much higher rate.
JAXenter: What are some challenges of the serverless model?
Matt Biilmann: We still see development teams spending a lot of time implementing backends and optimizing performance of the experience to end users.
While some of the implementation challenges have been solved if you’re just looking at deploying a serverless function, things get pretty tricky as you look at delivering serverless across the entire web experience. The app might call on a serverless function for one piece of data, call on a longer running function to accomplish something asynchronously, trigger a custom behavior at the network edge such as localizing content, and use compute resources to compile an update to the static content when a change is made from the CMS. All of this can call on serverless compute resources. What teams want is a frontend approach to orchestrating all of these services.
The second challenge has to do with performance. If developers are looking at server side rendering alone to deliver a web experience, it’s typically too slow and can’t compete with the speed and efficiency of pre-rendering. That’s why development teams are turning to Jamstack as a way to get the best of both worlds.
Frontend teams don’t just build UIs anymore—they can start to help themselves with API-accessed backends that cater to their requirements.
JAXenter: And how might those challenges be overcome?
Matt Biilmann: To overcome implementation challenges, Jamstack platforms offer a simple frontend workflow for developing and accessing cloud-scale backend services. Serverless functions, long-running asynchronous functions, edge compute logic, and pre-compute resources to compile the app – are all managed and deployed alongside the UI code from a single repo.
To overcome the challenge of performance, teams are moving to Jamstack, which allows for a more hybrid approach, taking the best parts of serverless and combining it with lightning-fast pre-rendered content. You effectively remove the performance tradeoff of serverless because static elements of the website are pre-rendered, and then a serverless backend is delivered either via APIs or right from the network edge in response to request/response logic.
JAXenter: What’s the future of serverless?
Matt Biilmann: When serverless started, it was about making the lives of backend developers easier. As it’s progressing, we’re seeing more frontend focused teams using serverless to build APIs and access data that wasn’t easily accessible. Serverless is going mainstream. The new assumption is that— if you can build business logic in code, then you should be able to build an API that works as a serverless function. Frontend teams don’t just build UIs anymore—they can start to help themselves with API-accessed backends that cater to their requirements.
Thank you for talking to us!