{"id":67130,"date":"2019-06-21T04:18:50","date_gmt":"2019-06-21T11:18:50","guid":{"rendered":"http:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/"},"modified":"2019-06-21T04:18:50","modified_gmt":"2019-06-21T11:18:50","slug":"jamstack-fundamentals-what-what-and-how","status":"publish","type":"post","link":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/","title":{"rendered":"JAMstack Fundamentals: What, What And How"},"content":{"rendered":"<link rel=\"canonical\" href=\"https:\/\/www.smashingmagazine.com\/2019\/06\/jamstack-fundamentals-what-what-how\/\"><title>JAMstack Fundamentals: What, What And How<\/title><\/p>\n<article>\n<header>\n<h1>JAMstack Fundamentals: What, What And How<\/h1>\n<address>Vitaly Friedman<\/address>\n<p>                  <time datetime=\"2019-06-20T14:30:59+02:00\">2019-06-20T14:30:59+02:00<\/time><time datetime=\"2019-06-21T11:06:17+00:00\">2019-06-21T11:06:17+00:00<\/time><\/header>\n<p>We love pushing the boundaries on the web, and so we\u2019ve decided to try something new. You probably have heard of <a href=\"https:\/\/jamstack.org\/\">JAMstack<\/a> \u2014 the new web stack based on JavaScript, APIs, and Markup \u2014 but what does it mean for your workflow and when does it make sense in your projects?<\/p>\n<p>As a part of our <a href=\"https:\/\/smashingmagazine.com\/membership\">Smashing Membership<\/a>, we run <em>Smashing TV<\/em>, a series of live webinars, every week. No fluff \u2014\u00a0just practical, actionable webinars with a live Q&#038;A, run by well-respected practitioners from the industry. Indeed, the <a href=\"https:\/\/www.smashingmagazine.com\/smashing-tv\/\">Smashing TV schedule<\/a> looks pretty dense already, and it\u2019s free for Smashing Members, along with recordings \u2014\u00a0<em>obviously<\/em>.<\/p>\n<p>We\u2019ve kindly asked <a href=\"https:\/\/twitter.com\/philhawksworth\">Phil Hawksworth<\/a> to run a webinar explaining what JAMStack actually means and when it makes sense, as well as how it affects tooling and front-end architecture. The one hour-long webinar is now available as well. We couldn\u2019t be happier to welcome Phil to co-MC our upcoming <a href=\"https:\/\/smashingconf.com\/toronto-2019\/\">SmashingConf Toronto<\/a> (June 25-26) and run <a href=\"https:\/\/jamstackconf.com\/london\/\">JAMStack_conf London<\/a>, which we co-organize on July 9-10 this year as well. So, let\u2019s get into it!<\/p>\n<figure><\/figure>\n<p><span>Phil Hawksworth:<\/span> Excellent, okay, well let\u2019s get into it then. Just by way of a very quick hello, I mean I\u2019ve said hello already, Scott\u2019s given me a nice introduction. But yes, I currently work at Netlify, I work in the developer experience team there. We are hopefully going to have plenty of time for Q&#038;A but, as Scott mentioned, if you don\u2019t get a chance to ask questions there, or if you just rather, you can ping them directly at me on Twitter, so my Twitter handle is my names, it\u2019s Phil Hawksworth, so any time you can certainly ask me questions about JAMstack or indeed anything on Twitter.<\/p>\n<p><span>Phil Hawksworth:<\/span> But I want to start today just by kind of going back in time a little bit to this quote which really resonates very, very strongly with me. This is a quote from the wonderful Aaron Schwartz who, of course, contributed so much to the Creative Commons and the open web and he wrote this on his blog way back in 2002, and he said, \u201cI care about not having to maintain cranky AOL server, Postgres and Oracle installs.\u201d AOL server, I had to look up to remind myself was an open source web server at the time.<\/p>\n<p><span>Phil Hawksworth:<\/span> But this chimes really strongly with me. I also don\u2019t want to be maintaining infrastructure to keep a blog alive, and that\u2019s what he was talking about. And it was in this blog post on his own blog and it was titled \u201cBake, Don\u2019t Fry\u201d. He was picking on a term that someone who\u2019d built a CMS recently had started to use, and he kind of popularized this term about baking (Bake, Don\u2019t Fry); what he\u2019s talking about there is pre-rendering rather than rendering on demand, so baking the content ahead of time, rather than frying it on demand when people come and ask for it \u2014 getting things away from request time and into kind of build time.<\/p>\n<p><span>Phil Hawksworth:<\/span> And when we\u2019re talking about pre-rendering and rendering, what we mean by that is we\u2019re talking about generating markup. I feel a bit self-conscious sometimes talking about kind of server render or isomorphic rendering or lots of these kind of buzzwordy terms; I got called out a few years ago at a conference, Frontiers Conference in Amsterdam when I was talking about rendering on the server and someone said to me, \u201cYou mean generating HTML? Just something that outputs HTML?\u201d And that\u2019s, of course, what I mean.<\/p>\n<p><span>Phil Hawksworth:<\/span> But all of this kind of goes a long way towards simplifying the stack. When we think about the stack that we serve websites from; I\u2019m all about trying to simplify things, I\u2019m super keen on trying to simplify the stack. And that\u2019s kind of at heart of this thing called \u201cJAMstack\u201d and I want to try and explain this a little bit. The \u201cJAM\u201d in JAMstack stands for JavaScript, APIs and Markup. But that\u2019s not enough really to help us understand what it means \u2014 what on earth does that really mean?<\/p>\n<p><span>Phil Hawksworth:<\/span> Well, what I want to try and do in the next half hour or so, is I want to kind of expand on that definition and give more of a description of what JAMstack is. I want to talk a bit about the impact and the implications of JAMstack, and, you know, think about what that can give us as to why we might choose it. Along the way, I\u2019m going to try to mention some of the tools and services that will be useful, and hopefully, I\u2019ll wrap up with some resources that you might want to dig into and perhaps mention some first steps to get you under way.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, that\u2019s the plan for the next half-hour. But, I want to, kind of, come back to this notion about simplifying the stack, because, hopefully, people who join this or have come to watch this video later on, maybe you\u2019ve got a notion of what JAMstack is, or maybe it\u2019s a completely new term, and you\u2019re just curious. But, ultimately, there are a lot of stacks out there, already. There are lots of ways that you can deliver a website. It feels like we\u2019ve been building different types of infrastructure for a really long time, whether that\u2019s a LAMP stack or the MAMP stack, or the \u2014 I don\u2019t know \u2014 the MEAN stack. There\u2019s a bunch of them floating by on the screen here. There are lots and lots of them.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, why on earth would we need another one? Well, JAMstack is, as I mentioned, is JavaScript\/API\/Markup, but if we try and be a tiny bit more descriptive, JAMstack is intended to be a modern architecture, to help create fast and secure sites and dynamic apps with JavaScript\/APIs and pre-rendered markup, served without web servers, and it\u2019s this last point which is, kind of, something that sets it apart and maybe, makes it a little bit more, kind of, interesting and unusual.<\/p>\n<p><span>Phil Hawksworth:<\/span> This notion of serving something without web servers, that sounds either magical or ridiculous, and hopefully, we\u2019ll figure out what along the way. But to try and shed some light over this and describe it in a little bit more detail, it\u2019s sometimes useful to compare it to what we might think of as a traditional stack, or a traditional way of serving things on the web. So, let\u2019s do that just for a second. Let\u2019s just walkthrough, perhaps, what a request might look like as it gets serviced in a traditional stack.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, in this scenario, we got someone opening up a web browser and making a request to see a page. And maybe that request hits a CDN, but probably, more likely, it hit some other infrastructure that we are hosting \u2014 as the people who own this site. Maybe we tried to make sure that this is going to scale under lots of load because we, obviously, want a very popular and successful sight. So, perhaps we got a load balancer, that has some logic in it, which will service that request to one of a number of web servers that we\u2019ve provisioned and configured and deployed to. There might be a number of those servers.<\/p>\n<p><span>Phil Hawksworth:<\/span> And those servers will execute some logic to say, \u201cOkay, here\u2019s our template, we need to populate that with some data.\u201d We might get our data from one of a number of database servers that will perform some logic to look up some data, return that to the web server, create a view that we then pass back through the load balancer. Perhaps, along the way, calling off to CDN, stashing some assets in the CDN, and I should clarify, a CDN is a Content Delivery Network, so a network of machines distributed around the Internet to try and get request service as close to possible to the user and add things, like caching.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, we might stash some assets there, and ultimately, return a view into the browser, into the eyeballs of the user, who gets to then experience the site that we built. So, obviously, that\u2019s, either, an oversimplification or a very general view of how we might service a request in a traditional stack. If we compare that to the JAMstack, which is servicing things in a slightly different way, this is how it might look.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, again, same scenario, we\u2019re starting in a web browser. We\u2019re making a request for a view of the page, and that page is already in a CDN. It serves statically from there, so it\u2019s returned to the user, into the browser, and we\u2019re done. So, obviously, a very simplified view, but straight away, you can start to see the differences here in terms of complexity. In terms of places that we need to manage code, deeply code, all of those different things. So, for me, one of the core attributes one of a JAMstack, is that it means that you\u2019re building a site that\u2019s capable of being served directly from a CDN, or even from a static file server. CDN is something that we might want to put in place to handle load, but ultimately, this could be served directly from any kind of static file server, kind of static hosting infrastructure.<\/p>\n<p><span>Phil Hawksworth:<\/span> JAMstack, kind of, offers an opportunity to reduce complexity. Just comparing those two parts of the diagram that we\u2019ll come back to a few times, over the course of the next half hour, you can see that it\u2019s an opportunity to reduce complexity and reduce risk. And so, it means that we can start to enjoy some of the benefits of serving static assets, and I\u2019m going to talk about what those are a little bit later on. But you might be looking at this and thinking, \u201cWell, great, but isn\u2019t this just the new name for static websites?\u201d That\u2019s a reasonable thing to level at me when I\u2019m saying, \u201cWe\u2019re going to serve things statically.\u201d<\/p>\n<p><span>Phil Hawksworth:<\/span> But I want to come back to that. I want to talk about that a little bit more, but first of all, I want to, kind of, talk about this notion of stacks and what on earth is a stack, anyway? And I think of a stack as the layers of technology, which deliver your website or application. And we\u2019re not talking about the build pipeline, or the development process, but certainly the way we serve sites can have a big impact on how we develop and how we deploy things, and so on.<\/p>\n<p><span>Phil Hawksworth:<\/span> But here, we\u2019re talking about the technology stack, the layers of technology, that actually deliver your website and your application to the users. So, let\u2019s do another little comparison. Let\u2019s talk about the LAMP stack for a second.<\/p>\n<p><span>Phil Hawksworth:<\/span> The LAMP stack, you may remember, is made up of an apache web server, for doing things like the HCP routing and the serving of static assets. PHP, for some pre-processing, so pretty hyper-text processing; applying the logic, maybe building the views for the templates and what have you. And has some access to your data, by my NISQL, and then LINUX is the operating system that sits beneath all of that, keeps that all breathing. We can wrap that up together notionally as this web server. And we may have many of these servers, kind of, sitting together to serve a website.<\/p>\n<p><span>Phil Hawksworth:<\/span> That\u2019s a, kind of, traditional look at the LAMP stack, and if we compare that to the JAMstack, well, here, there\u2019s a critical change. Here, we\u2019re actually moving up level, rather than thinking about the operating system and thinking about how we run the logic to deliver a website. Here we\u2019re making an assumption that we\u2019re going to be serving these things statically. So, we\u2019re doing the ACP routing, and the serving of assets from a static server. That can be reasonably done. We got very good at this, over the years, building ways to deliver static websites, or static assets.<\/p>\n<p><span>Phil Hawksworth:<\/span> This might be a CDN, and again, we\u2019ll talk about that in a moment. But the area of interest for us, is happening more in the browser. So, here, this is where our markup is delivered and is parsed. This is where JavaScript can execute, and this is happening in the browser. In many ways, the browser has become the runtime for the modern web. Rather than having the runtime in the server infrastructure, itself, now we\u2019ve moved that up a level, closer to the user, and into the browser.<\/p>\n<p><span>Phil Hawksworth:<\/span> When it comes to accessing data, well, that\u2019s happening through, possibly, external APIs, making calls via JavaScripts to these external APIs to get server access, or we can think APIs as the browser APIs, being able to interact with JavaScript with capabilities right there in your browser.<\/p>\n<p><span>Phil Hawksworth:<\/span> Either way, the key here about the JAMstack is that, we\u2019re talking about things that are pre-rendered: they\u2019re served statically and then, they maybe progressively enhanced in the browser to make use of browser APIs, JavaScripts, and what have you.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, let\u2019s just do this little side-by-side comparison here. Again, I just want to kind of reiterate that the JAMstack has moved up a level to the browser. And if we see the two sides of this diagram, with the LAMP stack on the left and effectively, the JAMstack on the right, you might even think that, well, even when we were building things with the LAMP stack, we\u2019re still outputting mark-up. We\u2019re still outputting JavaScript. We might still be accessing APIs. So, in many ways, the JAMstack is almost like a subset of what we were building before.<\/p>\n<p><span>Phil Hawksworth:<\/span> I used to sometimes talk about JAMstack as the assured stack, because it\u2019s assures a set of tools and technologies that we need to deliver a site. But, either way, it\u2019s a much simplified way of delivering a site that, kind of, does away with the need for things to execute and perform logic at the server at request time.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, this can do a lot of things. This can, kind of, simplify deployments and again, I\u2019m going to call back to this diagram from time-to-time. If we think about how we deploy our code and our site, for every deploy, from the very first one, through the whole development lifecycle, all the way through the life of the website. On the traditional stack, we might be having to change the logic and the content for every box on that diagram.<\/p>\n<p><span>Phil Hawksworth:<\/span> Whereas, in the JAMstack, when we\u2019re talking about deploying, we\u2019re talking at getting things to the CDN, getting things to the static server, and that\u2019s what the deployment entails. The build, the kind of logic that runs the build \u2014 that can run anywhere. That doesn\u2019t need to run in the same environment that\u2019s hosting the web server. In fact, it doesn\u2019t! It starts the key to the JAMstack. We put the separation at what happens at request time, serving these static assets, versus what happens at build time, which can be your logic that you run to build and then to the deployment.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, this kind of decoupling is a key thing, and I\u2019m going to come back to that later on. We\u2019ve got very good at serving static files, and getting things to a CDN or getting things to the file system (the file server) is somewhere that we\u2019ve seen huge, kind of, advancement over the last few years. There are a lot of tools and processes, now, that can help us do this really well. Just to call out a few services that can serve static assets well and give workflows to getting your build to that environment, they\u2019re the usual suspects that you might imagine the big clouds infrastructure providers, like Azure, AWS, and Google Cloud.<\/p>\n<p><span>Phil Hawksworth:<\/span> But then, there are others. So, the top one on the right is a service called Surge, which has been around for a few years. It allows you to run a command in your build environment and deploy your assets through to their hosting environment. Netlify, the next one down, is where I work and we do very much the same thing but we have different automation as well. I could go into it another time. And the one on the bottom, another static hosting environment site, called Now.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, there\u2019s a bunch of different options for doing this, and all of these spaces provide different tooling for getting to the CDN, as quickly as possible. Getting your sites deployed in the most seamless way that we can. And they all have something in common where they\u2019re building on the principal of running something locally. I often think of a static site generator as something that we might run in a build which when we run that, it takes things like content and templates and maybe, data from different services and it outputs something which can be served statically.<\/p>\n<p><span>Phil Hawksworth:<\/span> We can preview that locally in our static server. Something that is kind of simple to do on any local development environment, and then the process of deploying that is getting that to the hosting environment and ideally, out to a CDN in order to get, kind of, scale. So, with that kind of foundation laid out, I want to address a bit of a common misconception when it comes to JAMstack sites. And I didn\u2019t do myself any favors by opening this up as describing JAMstack sites as being JavaScript, APIs, and Markup. Because the common misconception is that every JAMstack site has to be JavaScript and APIs, and Markup, but this kind of thing that we\u2019ve overlooked is that we don\u2019t have to use all three \u2014 every one one of these is, kind of, optional. We can use as much, or as little of these as we like. In the same way that a LAMP stack site wouldn\u2019t necessarily need to be hitting a data base. Now, I\u2019ve built things in the past that are served by an apache server, on a Linux machine, and I\u2019ve been using PHP, but I haven\u2019t been hitting a database and I wouldn\u2019t start to rename a stack necessarily for that.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, if we think about what is a JAMstack site, then it could be a bunch of different things. It might be something that\u2019s built out with a static site generator, like Jekyll, pulling content from YAML files to build a site that has no JavaScript, doesn\u2019t hit APIs at all, and we serve it on something, like GitHub Pages. Or, that would be a JAMstack site. Or maybe we\u2019re using a static site generator, like Gatsby, which is, rather in a Ruby environment for Jekyll, now this is a JavaScript static site generator built in the React ecosystem.<\/p>\n<p><span>Phil Hawksworth:<\/span> That might be pulling content again, and it\u2019s organizing Markdown files. It might be enriching that with calls to APIs, GraphQL\u2019s APIs. It might be doing things in the browser, like doing JavaScript hydration of populating templates right there in the browser. And it might be served on Amazon S3. Is that a JAMStack site? Yeah, absolutely!<\/p>\n<p><span>Phil Hawksworth:<\/span> Moving on to a different static site generator, Hugo, which is built with Go! Again, we might be organizing content in Markdown files, adding interactions in the browser using JavaScript. Maybe not calling any external APIs and maybe hosting that on Google Cloud. Is it JAMstack? Absolutely! You see, I\u2019m building to a theme here. Using something like Nuxt, another static site generator, now built in the View ecosystem. Maybe that\u2019s pulling content from different adjacent files? Again, we might be using JavaScript interactions in the browser, perhaps calling APIs to do things like e-Commerce, serving it another static site. Another hosting infrastructure like Netlify, is it a JAMstack? Yes, it is!<\/p>\n<p><span>Phil Hawksworth:<\/span> But we might even go, you know, go off to this side end of the scale, as well. And think about a handmade, progressive web app that we\u2019ve built artisanally, hand-rolled, JavaScript that we built ourselves. We\u2019re packaging it up with webpack. We\u2019re maybe using JavaScript web tokens and calling out to APIs to do authentication, interacting with different browser APIs, hosting it on Azure. Yes, that\u2019s JAMstack as well!<\/p>\n<p><span>Phil Hawksworth:<\/span> And, you know, all of these things, and many more, can be considered JAMstack, because they all share one attribute in common and that is none of them are served with an origin server. None of them have to hit a server that performs logic at request time. These are being served as static assets, and then enriched with JavaScript and calls to APIs, afterwards.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, again, I just want to reiterate that a JAMstack means it\u2019s capable of being served directly from the CDN. So, I want to just call out some of the impacts and implications of this, because why would we want to do this? Well, the first notion is about security, and we\u2019ve got a greatly reduced surface area for attack, here. If we think about (coming back to this old diagram again), the places where we might have to deal with an attack, we have to secure things like the load balancer, the webservers, the database servers. All of these things, we have to make sure aren\u2019t able to be penetrated by any kind of an attack and, indeed, the CDN.<\/p>\n<p><span>Phil Hawksworth:<\/span> If the more pieces we can take out of this puzzle, the fewer places that can be attacked and the fewer places we have to secure. Having few moving parts to attack is really very valuable. At Netlify, we operate our own CDNs, so we get the luxury of being able to monitor the traffic that comes across it, and even though all of the sites hosted on Netlify, all of the JAMstack sites that you might imagine, none of them have a WordPress admin page on them because it\u2019s completely decoupled. There is no WordPress admin, but we see a huge volume of traffic, probing for things like WP Admin, looking for ways in, looking for attack vectors.<\/p>\n<p><span>Phil Hawksworth:<\/span> I really love some of the things that Kent C. Dodds has done. I don\u2019t know if you are familiar with the React community, you\u2019ve probably encountered Kent C. Dodds in the past. He doesn\u2019t use WordPress, but he still routes this URL, the WPAdmin. I think he used to route it through to a Rick Roll video on YouTube. He\u2019s certainly been trolling people who have gone probing for it. But, the point is, by decoupling things in that way and, kind of, moving things that happen, build time from what happens in request time, we can just drastically reduce our exposure. We\u2019ve got no moving parts at request time. The moving parts are all completely decoupled at build time. Potentially, on completely, well, necessarily on completely different infrastructure.<\/p>\n<p><span>Phil Hawksworth:<\/span> This, of course, also has an impact on performance, as well. Going back to our old friend here, the places we might want to try and improve performance across the stack here, when there\u2019s logic that needs to be executed at these different places. The way that this often happens in traditional stacks is, they start to add layers, add static layers, in order to improve performance. So, in other words, try and find ways that we can start to behave as if it\u2019s static. Not have to perform that logic at each level of the stack in order to speed things up. So, we\u2019re starting to introduce things like caching all over the infrastructure and obvious places we might find to do that is in the web server, rather than perform that logic, we want to serve something immediately without performing that logic.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, it\u2019s kind of like a step towards, kind of, being pseudo-static. Likewise in database servers, we want to add caching layers to cache-com queries. Even in the low balance, the whole CDN, you can think of as a cache. But on the traditional stack, we need to figure out how to manage that cache, because not everything will be cached. So, there\u2019s going to some logic about. What needs to be dynamically populated versus what can be cached. And the JAMstack model, everything is cached. Everything is cached from the point that the deployment is done, so we can think about it completely differently.<\/p>\n<p><span>Phil Hawksworth:<\/span> This, then, starts to, kind of, hint through to scaling, as well. And by scale, I\u2019m talking about, how do we handle large loads of traffic? Traditional stacks will start to add infrastructure in order to scale. So, yes, to caching. We\u2019re starting to put in place in our traditional stack. That will help \u2014 to a degree. What typically happens is, in order to handle large loads of traffic, we\u2019ll start expanding the infrastructure and starting to add more servers, more pieces to handle these requests, costing these things out and estimating the load is a big overhead and it can be a headache for anyone doing technical architecture. It certainly was for me, which is why I was starting to lean much more towards doing the JAMstack approach where I just know that everything is served from the CDN, which is designed by default to handle scale, to handle performance right out of the gate.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, I also want to give a nod to developer experience, and the impact this can have there. Now, developer experience should never be seen as something which trumps user experience, but I believe that a good developer experience can reduce friction, can allow for developers to do a much better job of building up to great user experiences!<\/p>\n<p><span>Phil Hawksworth:<\/span> So, when we think about where the developer experience lives, and where the areas of concern for a developer are here: well, in a traditional stack, we might need to think about how we get the code to all of these different parts of the infrastructure, and how they all play together. In the JAMstack world, really, what we\u2019re talking about is this box here at the bottom. You know, how do we ran the build and them, how do we automate a deployment to get something served in the first place? And the nice thing is, that in the JAMstack model, what you do in that build is completely up to you.<\/p>\n<p><span>Phil Hawksworth:<\/span> That\u2019s a really well-defined problem space, because ultimately, you\u2019re trying to build something you can serve directly from a CDN. You want to pre-render something, using whatever tools you like: whether it\u2019s a static site generator built in Ruby or Python or JavaScript or Go or PHP, you have the freedom to make that choice. And so, that can create a much nicer environment for you to work in. And also, it creates an opportunity to have real developer confidence because a real attribute of JAMstack sites is that they can be much more easily served as immutable and atomic deployment.<\/p>\n<p><span>Phil Hawksworth:<\/span> And I want to, kind of, jump away from the slides just for a moment, to describe what that means, because an immutable deployment and an atomic deployment can\u2026 (that can just sound a little bit like marketing speak) but what I\u2019m going to do, is I\u2019m going to jump into my browser. Now \u2026 actually, I\u2019m going to go back for a second. Let me\u2026 just do this.<\/p>\n<p><span>Phil Hawksworth:<\/span> Here we are. This will be easier. Jumping right into the page. Now, Scott, you will tell me, Scott, if you can\u2019t see my browser, I\u2019m hoping. Now, assuming everyone can see my browser.<\/p>\n<p><span>Scott:<\/span> Everything looks good.<\/p>\n<p><span>Phil Hawksworth:<\/span> Excellent! Thank you very much!<\/p>\n<p><span>Phil Hawksworth:<\/span> So, what I\u2019m doing here, is I\u2019m using Netlify as an example, as an example of the service. But, this is an attribute which is common to sites that can be hosted, statically. So, when we talk about an immutable deployment, what we mean is, that rather each deployment of code having to touch lots of different parts of the infrastructure, and change lots of things, here we\u2019re not mutating the state of the site on the server. We\u2019re creating an entirely new instance of the site for every deployment that\u2019s happened. And we can do that because the site is a collection of static assets.<\/p>\n<p><span>Phil Hawksworth:<\/span> Here, I\u2019m looking at the deployment that have happened from my own website. I\u2019ll give you a treat. There you are, that\u2019s what it looks like. It\u2019s just a blog, it doesn\u2019t look like anything particularly remarkable or exciting. It\u2019s a statically generated blog, but what I have here is every deployment that\u2019s ever happened, lives on in perpetuity, because it\u2019s a collection of static assets that are served from a CDN. Now, I could go back as far as my history can carry me and go and look at the site, as it was back in\u2026 when was this? This was August, 2016. And by virtue of it being a set of static assets, we\u2019re able to host this on its own URL that lives on in perpetuity and if I even wanted to, I could decide to go in and publish that deployment.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, now, anyone\u2019s who\u2019s looking at my website, if I go back to my website here, if I refresh that page, now that\u2019s being served directly from the CDN with the assets that were there before. Now, I can navigate around again. Here, you can see. Look, I was banging on about this, I was using these terrible terms like isomorphic rendering and talking about the JAMstack back in 2016. So, this is now what\u2019s being served live on my site. Again, because there are mutual deployments that just live on forever. I\u2019m going to just put my own, kind of, peace of mind, I\u2019m going to \u2014 is this the first page? Yeah. I\u2019m going to go back to my latest deployment. I\u2019ll have to shut again, and get me back into the real world. Let me just make sure this is okay.<\/p>\n<p><span>Phil Hawksworth:<\/span> Okay! Great! So, then now, this is back to serving my previous version, or my latest version of the site. I\u2019ll hop back to keynote. So, this is possible because things are immutable and atomic. The atomic part of that means, again, that the deployment is completely contained. So, you never get the point where some of the assets are available on the web server, but some of them won\u2019t. Only when everything is there in context and everything is there, complete, do we toggle the serving of the site to the new version. Again, this is the kind of thing you can do much more easily if you\u2019re building things out as a JAMstack site that serves directly from the CDN as a bunch of assets.<\/p>\n<p><span>Phil Hawksworth:<\/span> I noticed that my timer has reset, after going back and forward from keynote, so I think I have about six or seven minutes left. Tell me, Scott, if\u2014<\/p>\n<p><span>Scott:<\/span> So, yeah, we\u2019re still good for about ten minutes.<\/p>\n<p><span>Phil Hawksworth:<\/span> Ten minutes? Okay, wonderful!<\/p>\n<p><span>Scott:<\/span> There\u2019s no rush.<\/p>\n<p><span>Phil Hawksworth:<\/span> Thank you, that should be good!<\/p>\n<p><span>Phil Hawksworth:<\/span> So, just switching gear a tiny bit and talking about APIs and services (since APIs is part of JAMstack), the kind of services that we then might be able to use is mostly JAMstack. You know, we might be using services that we built in-house, or we might be using bought-services. There are lots of different providers who can do things for us, and that\u2019s because that\u2019s their expertise. Through APIs, we might be pulling in content from content management systems as a service, and there\u2019s a bunch of different providers for this, who specialize in giving a great content management experience and then, exposing the content through API, so you used to be able to pull them in.<\/p>\n<p><span>Phil Hawksworth:<\/span> Likewise, there are different ways that you can serve assets. People like Cloudary are great at this, for doing image optimization, serving assets directly to your sites, again, through APIs. Or what about e-Commerce? You know, there are places like Stripe or Snipcart that can provide us API, so that we don\u2019t have to build these services ourselves and get into the very complex issues that come with trying to build an e-Commerce engine. Likewise, identity, from people like Auth0 who are using Oauth. There are lots of services that are available and we can consume these things through APIs, either in the browser or at build time, or sometimes, a combination of both.<\/p>\n<p><span>Phil Hawksworth:<\/span> Now, some people might think, \u201cWell, that\u2019s fine, but I don\u2019t want to give the keys to the kingdom away. I don\u2019t want to risk giving these services over to external providers,\u201d and to that, I say, well, you know, vendors who provide a single service really depend on its success. If there\u2019s a company that\u2019s core business, or entire business, is in building-out an e-Commerce engine, an e-Commerce service for you, they\u2019re doing that for all of their clients, all of their customers, so they really depend on its success and they have the specialist skills to do that.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, that kind of de-risks it from you a great deal. Especially when you start to factor in the fact that you can have your technical and service-level contracts to give you that extra security. But it\u2019s not all about bought services, it\u2019s also about services you can build yourselves. Now, there\u2019s a number of ways that this can happen, but sometimes, you absolutely need a little bit of logic on the server. And so far, I\u2019ve just been talking about taking the server out of the equation. So, how do we do that?<\/p>\n<p><span>Phil Hawksworth:<\/span> Well, this is where serverless can really come to the rescue. Serverless and JAMstack, they just fit together really beautifully. And when I\u2019m talking about serverless, I\u2019m talking about no functions as a service. I know that serverless can be a bit of a loaded term, but here, I\u2019m talking about functions as a service. Because functions as a service can start to enable a real micro-services architecture. Using things like AWS Lambda or Google Cloud functions or similar functions as a service, can allow you to build out server infrastructure without a server. Now, you can start deploying JavaScript logic to something that just runs on demand.<\/p>\n<p><span>Phil Hawksworth:<\/span> And that means, you can start supplementing some of these other services with, maybe, very targeted small services you build yourselves that can run the serverless functions. These kind of smaller services are easier to reason about, understand, build out and they create much greater agility. I want to just mention a few examples and results from JAMstack sites. I\u2019m not going to go down the server list avenue too much, right now. We can, maybe, come back to that in the questions. I really just kind of want to switch gear and, thinking about time a little bit, talk about some examples and results.<\/p>\n<p><span>Phil Hawksworth:<\/span> Because there are some types of sites that lend themselves in a very obvious way to a JAMstack site. Things like the documentation for React, or Vuejs, those [inaudible 00:32:40], pre-rendered JAMstacks sites. As do sites for large companies, such as Citrix, this is a great example of Citrix multi-language documentation. You can actually view the video from the JAMstack conference that happened in New York, where Beth Pollock had worked on this project, talked about the change that went on in that project. From building on traditional, non-enterprised infrastructure to a JAMstack approach and building with Jekyll, which is not necessarily the fastest generating static site generator, but still, they saw a huge improvement.<\/p>\n<p><span>Phil Hawksworth:<\/span> Beth talked about the turnaround time for updates went from weeks to minutes. Maybe people are kind of frowning at the idea of weeks for updates to sites, but sometimes in big complex infrastructure, with lots of stakeholders and lots of moving parts, this really is the situation we\u2019re often finding ourselves in. Beth also talked about estimating the annual cost savings for this move to a JAMstack site. To get the site running properly, estimated their savings of around 65%. That\u2019s huge kind of savings. Changing gear to a slightly different type of site, something a little closer to home, Smashing Magazine itself is a JAMstack site, which might be a little bit surprising, because on one hand, yes, there\u2019s lots of articles and it\u2019s also content, which is published regularly, but not every minute of the day, for sure.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, that might lend itself, perhaps, for something that\u2019s pre-generated, but of course, there\u2019s also a membership area and an event section, and a job board, and e-Commerce, and all of these things. This is all possible on the JAMstack because not only are we pre-rendering, but we\u2019re also enriching things with JavaScript and the front end to call out to APIs, which let some of these things happen. The project that I think I saw Vitaly arrive in the call, so that\u2019s going to be good, we might be able to come back to this in a few minutes.<\/p>\n<p><span>Phil Hawksworth:<\/span> But the project that migrated, Smashing Magazine onto a JAMstack approach, I believe, simplified the number of platforms from five, effectively down to one. And I\u2019m using Vitaly\u2019s words directly here: Vitaly talked about having some caching issues, trying to make the site go quickly, using probably every single WordPress caching plug-in out there, and goodness knows, there are a few of them! So, Smashing Magazine saw an improvement in performance, time to first load went from 800 milliseconds to 80 milliseconds. Again, I\u2019m simplifying the infrastructure that served the site up in the first place. So, it\u2019s kind of interesting to see the performance gains that can happen there.<\/p>\n<p><span>Phil Hawksworth:<\/span> Another totally different type of site. This is from the Google Chrome team, who built this out to demonstrate at Google I\/O this year. This very much feels like an application. This is Minesweeper in a browser. I apologize if you\u2019re watching me play this. I\u2019m not playing it while talking to you; I recorded this sometime ago and it\u2019s agony to see how terrible I seem to be at Minesweeper while trying to record. That\u2019s not a mine, that can\u2019t be!<\/p>\n<p><span>Phil Hawksworth:<\/span> Anyway, we\u2019ll move on.<\/p>\n<p><span>Phil Hawksworth:<\/span> The point of that is, this is something that feels very much more like an app, and it was built in a way to be very responsible about the way it used JavaScript. The payload to interactive was 25KB. This progressively would download and use other resources along the way, but it meant that the time to interact was under five seconds on a very slow 3G network. So, you can be very responsible with the way you use JavaScript and still package up JavaScript, as part of the experience for a JAMstack site.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, I\u2019m kind of mindful of time. We\u2019re almost out of time, so what is the JAMstack? Well, it\u2019s kind of where we started from. JAMstack sites are rendered in advance: they\u2019re not dependent on an origin server (that\u2019s kind of key), and they may be progressively enhanced in the browser with JavaScript. But as we\u2019ve shown, you don\u2019t have to use JavaScript at all. You might just be serving that statically, ready to go, without that. It\u2019s an option available to you.<\/p>\n<p><span>Phil Hawksworth:<\/span> This key tenant, I think of, JAMstack sites is they\u2019re served without web service. They\u2019re pre-rendered and done in advance.<\/p>\n<p><span>Phil Hawksworth:<\/span> If you\u2019re interested in more, it\u2019s already been mentioned a little bit, there is a conference in London in July \u2014 July 9th and 10th. The speakers are going to be talking about all kinds of things to do with performance in the browser, things that you can do in the browser, results of building on the JAMstack and things to do with serverless.<\/p>\n<p><span>Phil Hawksworth:<\/span> There\u2019s also a bunch of links in this deck that I will share, after this presentation, including various bits and pieces to do with static site generation, things like headless CMS, the <a href=\"http:\/\/jamstack.org\/\">jamstack.org<\/a> site itself, and a great set of resources on a website called \u201cThe New Dynamic\u201d which is just always full of latest information on JAMstack. We\u2019re out of time, so I\u2019ll wrap it up there, and then head back across to questions. So, thanks very much for joining and I\u2019d love to take questions.<\/p>\n<p><span>Scott:<\/span> Thanks, Phil. That was amazing, thank you. You made me feel quite old when you pulled up the Minesweeper reference, so\u2014<\/p>\n<p><span>Phil Hawksworth:<\/span> (laughs) Yeah, I can\u2019t take any credit for that, but it\u2019s kind of fascinating to see that as well.<\/p>\n<p><span>Scott:<\/span> So, I do think Vitaly is here.<\/p>\n<p><span>Vitaly:<\/span> Yes, always in the back.<\/p>\n<p><span>Phil Hawksworth:<\/span> I see Vitaly\u2019s smiling face.<\/p>\n<p><span>Vitaly:<\/span> Hello everyone!<\/p>\n<p><span>Phil Hawksworth:<\/span> So, I\u2019m going to hand it over to Vitaly for the Q&#038;A, because I seem to have a bit of a lag on my end, so I don\u2019t want to hold you guys up. Vitaly, I\u2019ll hand it over to you.<\/p>\n<p><span>Scott:<\/span> Okay. Thanks, Scott.<\/p>\n<p><span>Vitaly:<\/span> Thanks, Scott.<\/p>\n<p><span>Vitaly:<\/span> Hello\u2014<\/p>\n<p><span>Vitaly:<\/span> Oh, no, I\u2019m back. Hello everyone. Now Scott is back but Phil is gone.<\/p>\n<p><span>Scott:<\/span> I\u2019m still here! Still waiting for everything.<\/p>\n<p><span>Vitaly:<\/span> Phil is talking. Aw, Phil, I\u2019ve been missing you! I haven\u2019t seen you, for what, for days, now? It\u2019s like, \u201cHow unbelievable!\u201d Phil, I have questions!<\/p>\n<p><span>Vitaly:<\/span> So, yeah. It\u2019s been interesting for us, actually, to move from WordPress to JAMstack \u2014 it was quite a journey. It was quite a project, and the remaining moving parts and all. So, it was actually quite an undertaking. So, I\u2019m wondering, though, what would you say, like if we look at the state of things and if we look in the complexes, itself, that applications have. Especially if you might deal with a lot of legacy, imagine you have to deal with five platforms, maybe seven platforms here, and different things. Maybe, you have an old legacy project in Ruby, you have something lying on PHP, and it\u2019s all kind of connected, but in a hacky way. Right? It might seem like an incredible effort to move to JAMstack. So, what would be the first step?<\/p>\n<p><span>Scott:<\/span> So \u2026 I mean, I think you\u2019re absolutely right, first of all. Re-platforming any site is a big effort, for sure. Particularly if there\u2019s lots of legacy. Now, the thing that I think is kind of interesting is an approach that I\u2019ve seen getting more popular, is in identifying attributes of the site, parts of the site, that might lend themself more immediately to being pre-generated and served statically than others. You don\u2019t necessarily have to everything as a big bang. You don\u2019t have to do the entire experience in one go. So, one of the examples I shared, kind of, briefly was the Citrix documentations site.<\/p>\n<p><span>Scott:<\/span> They didn\u2019t migrate all of <a href=\"http:\/\/citrix.com\/\">Citrix.com<\/a> across to being JAMstack. They identified a particular part that made sense to be pre-rendered, and they built that part out. And then, what they did was they started to put routing in front of all the requests that would come into their infrastructure. So, it would say, \u201cOkay, well, if it\u2019s in this part of the past the domain, either in the sub-domain or maybe, through to a path, route that through something which is static, then the rest of it, pass that through to the rest of the infrastructure.<\/p>\n<p><span>Scott:<\/span> And I\u2019ve seen that happen, time and time again, where with some intelligent redirects, which, thankfully, is something that you can do reasonably simply on the JAMstack. You can start to put fairly expressive redirect engines in front of the site. It means that you can pass things through just that section of the site that you tried to take on as a JAMstack project. So, choosing something and focusing on that first, rather than trying to do a big bang, where you do all of the legacy and migration in one. I think that\u2019s key, because, yeah, trying to do everything at once is pretty tough.<\/p>\n<p><span>Vitaly:<\/span> It\u2019s interesting, because just, I think, two days, maybe even today, Chris Coyier wrote an article renaming JAMstack to SHAMstack where, essentially, it\u2019s all about JavaScript in which we need think about steady coasting, because JavaScript could be hosted steadily as well. And it\u2019s interesting, because he was saying exactly that. He actually \u2014 when we think about JAMstack, very often, we kind of tend to stay in camps. It\u2019s either, fully rendered and it lives a static-thing. Somewhere there, in a box and it\u2019s served from a city and that\u2019s it, or it\u2019s fully-expressive and reactive and everything you ever wanted. And actually, he was really right about a few things, like identifying some of the things that you can off-load, to aesthetic-side, generated assets, so to say, to that area.<\/p>\n<p><span>Vitaly:<\/span> And, JAMstackify, if you might, say some of the fragments of your architecture. Well, that\u2019s a new term, I\u2019m just going to coin, right there! JAMstackify.<\/p>\n<p><span>Phil Hawksworth:<\/span> I\u2019m going to register the domain quickly, before anybody else.<\/p>\n<p><span>Phil Hawksworth:<\/span> And it\u2019s a nice approach. I think, it kind of makes my eye twitch a little bit when I hear that Chris Coyier has been redubbing it the SHAMstack, because it makes it sound like he thinks it\u2019s a shambles. But I know that he\u2019s really talking about static-hosting and markup, which I\u2014<\/p>\n<p><span>Vitaly:<\/span> Yes, that\u2019s right.<\/p>\n<p><span>Phil Hawksworth:<\/span> I really like, because the term JAMstack can be really misleading, because it\u2019s trying to cover so many different things and the point I was trying to, I probably hammered it many times in that slide, is that it can be all kinds of things. It\u2019s so broad, but the key is pre-rendering and hosting the core of the sites statically. It\u2019s very easy for us to get into religious wars about where it needs to be a React site. It has to be a React app, in order to be a JAMstack site, or it\u2019s a React app, so it can\u2019t be JAMstack. But, really, the crux of it is, whether you use JavaScript or not, whether you\u2019re calling APIs or not, if you pre-render and get things into a static host that can be very performant, that\u2019s the core of JAMstack.<\/p>\n<p><span>Vitaly:<\/span> Yes, absolutely.<\/p>\n<p><span>Phil Hawksworth:<\/span> We\u2019re very fortunate that browser\u2019s are getting so much more capable, and the APIs that are there within browser\u2019s themselves can allow us to do much more as well. So, that kind of opens the doors even further, but it doesn\u2019t mean that everything that we build as a JAMstack site has to make use of everything. Depending on what we\u2019re trying to deliver, that\u2019s how we should start to choose the tools that we\u2019re playing with to deploy those things.<\/p>\n<p><span>Vitaly:<\/span> Absolutely. We have Doran here. Doran, I think I know, Doran. I have a feeling that I know Doran. He\u2019s asking, \u201cDo you expect serverless to be gravitating towards seamless integration with JAMstack from [inaudible 00:44:36]? What is referred to as the A in JAM.<\/p>\n<p><span>Phil Hawksworth:<\/span> That\u2019s a great question, because I think, serverless functions are \u2014 they just go so well with JAMstack sites, because in many ways, in fact, I think someone once asked me if JAMstack sites are serverless, and so I squirmed about that question, because serverless is such a loaded term. But, in many ways, it\u2019s bang-on because I was talking, time and time again, about there\u2019s no origin server. There\u2019s no server infrastructure for you to manage. In fact, I once wrote a blog post called \u201cWeb Serverless,\u201d because the world needs another buzz term, doesn\u2019t it?<\/p>\n<p><span>Phil Hawksworth:<\/span> And really, the kind of point of that was, yes, we\u2019re building things without servers. We don\u2019t want to have to manage these servers, and serverless functions, or functions as a service, just fits into that perfectly. So, in the instances that you do need an API that you want to make a request to, where really it\u2019s not sensible for you to make that request directly from the browser. So, for instance, if you\u2019ve got secrets, or keys, in that request, you might not want those requests \u2014 that information \u2014 ever exposed in the client. But we can certainly proxy those things, and typically, traditionally, what we need to do then, is spin-up a server, have some infrastructure that was effectively doing little more than handling requests, adding security authentication to it and passing those requests on, proxying them back.<\/p>\n<p><span>Phil Hawksworth:<\/span> Serverless functions are perfect for that. They\u2019re absolutely ideal for that. So, I sometimes think of serverless functions, or functions of a service, almost as like an escape hatch, where you just need some logic on a server, but you don\u2019t want to have to create an entire infrastructure. And you can do more and more with that, and stipe the development pipelines for, development workflows, for functions as a service is maturing. It\u2019s getting more accessible for JavaScript developers to be able to build these things out. So, yeah, I really think those two things go together very nicely.<\/p>\n<p><span>Vitaly:<\/span> All right, that\u2019s a very comprehensive answer. Actually, I attended a talk just recently, where a front-end engineer from Amazon was speaking about serverless and Lamda functions they\u2019re using \u2014 I was almost gone. He was always speaking about Docker, and Kubernetes, and all those things, Devox World, I was sitting there, thinking, \u201cHow did he end up there. I don\u2019t understand what\u2019s going on!\u201d I had no idea what\u2019s going on.<\/p>\n<p><span>Phil Hawksworth:<\/span> Exactly, but the thing is, it used to be the\u2026 I was\u2026 I accepted that I didn\u2019t understand any of that world, but I didn\u2019t have any desire to, since that was for an entirely different discipline. And that discipline is still really important. You know, people who are designing infrastructure \u2014 that\u2019s still really key. But, it just feels, now, that I\u2019m tempted. As someone with a front-end development background, as a JavaScript developer, I\u2019m much more tempted to want to play in that world, because the tools are coming, kind of, closer to me.<\/p>\n<p><span>Phil Hawksworth:<\/span> It\u2019s much more likely that I might be able to use some of these things, and deliver things kind of safely, rather than just as an experiment of my own, which is where I used to be dappling. So, it feels like we\u2019re becoming more powerful as web developers, which is exciting to me.<\/p>\n<p><span>Vitaly:<\/span> Like Power Rangers, huh?<\/p>\n<p><span>Vitaly:<\/span> One thing I do want to ask you, though, and this is actually something we discussed already, maybe, a week ago, but I still wanted to bring it up, because the one thing that you mentioned in the session was the notion of having a stand-alone instance of every single deploy, which is really cool. The question, though, is if you have a large assignment, with tens of thousands of pages, you really don\u2019t want to redeploy every thing, every single time. So, essentially, if you have, like, if you\u2019re mostly using the static side of things. So, we had this idea for a while and I know this is actually something that you brought up last time. The idea of atomic deployments.<\/p>\n<p><span>Vitaly:<\/span> Where you actually, literally, were served some sort of div between two different versions of snapshots of the set-up. So, if you say, change the header everywhere, then, of course, every single page has to be redeployed. But if you change, maybe, a component, like let\u2019s say, carousel, that maybe effects only a 1000 pages, then it would make sense to redeploy 15000 pages. But only this 1000. So, can we get there? Is it a magical idea that\u2019s out there, or is it something that\u2019s quite tangible, at this point?<\/p>\n<p><span>Phil Hawksworth:<\/span> I think that is, probably, the Holy Grail for static site generators and this kind of model because, certainly, you\u2019ve identified probably the biggest hurdle to overcome. Or the biggest ceiling that you bump into. And that is websites that have many, tens of thousands or hundreds of thousands, or millions of URLs \u2014 the notion that the build can become very long. Being able to detect which URL\u2019s will change, based on a code change, is a challenge. It\u2019s not insurmountable, but it\u2019s a big challenge. Understanding what the dependency graph is across your entire site and then, intelligently deploying that \u2014 that\u2019s really tough to do.<\/p>\n<p><span>Phil Hawksworth:<\/span> Because as you mentioned, a component change might have very far-reaching implications but you \u2014 it\u2019s difficult, always, to know how that\u2019s going to work. So, there are a number of static site generators, the projects that are putting some weight behind that challenge, and trying to figure out how they do partial-regeneration and incremental builds. I\u2019m very excited that the prospect that that might get solved day, but at the moment, it\u2019s definitely a big challenge. You can start to do things like try to logically sharred your site, and think about, again, kind of similar to the migration issue. Well, this section I know is independent in terms of its, kind of, some of the assets that it uses, or the type of content that lives there, so I can deploy them individually.<\/p>\n<p><span>Phil Hawksworth:<\/span> But that\u2019s not ideal to me. That\u2019s not really the perfect scenario. One of the approaches that I\u2019ve explored a little bit, just as a proof of concept, is thinking about how you do things, like, making intelligent use of 404s. So, for instance, a big use case for very large signs, maybe news sites is, when they need a URL when a breaking news story happens, they need to be first to get it deploy out there. They need to get a URL up there. Things like the BBC News, you\u2019ll see that the news story will arrive on the website, and then overtime, they\u2019ll add to it, incrementally, but getting there first is key. So, having a build that takes 10 minutes, 20 minutes, whatever it\u2019s going to be, that could be a problem.<\/p>\n<p><span>Phil Hawksworth:<\/span> But, if they\u2019re content is abstracted and maybe used to have been called from an API. I mentioned content management systems that are abstracted, like Contentful, or Sanity, or a bunch of those. Anything that has a content API changes to that content structure that will trigger a build and we\u2019ll go through the run, but the other thing that could happen is that, well, if you publish your URL for that, and then publicize that URL, even if the build hasn\u2019t run, if someone hicks that URL, if the first stop on its 404 is instead of saying, \u201cWe haven\u2019t got it,\u201d is actually to hit that API directly, then, you can say, \u201cWell, the build hasn\u2019t finished to populate that yet, but I can do it in the client.\u201d I can go directly to the API, get that, populate it in the client.<\/p>\n<p><span>Vitaly:<\/span> Hmm, interesting.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, even while the build is still happening, you can start populating those things. And then, once the build\u2019s finished, of course it wouldn\u2019t hit a 404. You would hit that statically running page. So, there are techniques and there are strategies to tackle it, but still, it\u2019s a very long, rambling answer, I\u2019m sorry, but my conclusion is, yeah, that\u2019s a challenge. Fingers crossed we\u2019ll get better strategies.<\/p>\n<p><span>Vitaly:<\/span> Yeah, that\u2019s great. So, I\u2019m wondering, so, at this point, we really aren\u2019t thinking, not just what the performance in terms of the content delivering, but those in performance in terms of the build speed. Like building deployment. So, this is also something that we\u2019ve been looking into for, quite a bit of time now, as well.<\/p>\n<p><span>Vitaly:<\/span> One more thing I wanted to ask you. So, this is interesting, like this technique that you mentioned. How do you learn about this? This is just something people tend to publish on their own blogs or, is it some medium or is there a central repository where you can get some sort of case studios, of how JAMstack\u2014how companies moved while unloading, or have failed to move to JAMstack.<\/p>\n<p><span>Phil Hawksworth:<\/span> So, it\u2019s kind of maturing this landscape a little bit, at the moment. I mean, some of these examples, I think, I\u2019m in a very fortunate position, I work somewhere that I\u2019m in a role that I\u2019m playing with the toys, coming up with interesting ways to use it and start experimenting with them. So, these proofs of concepts are, kind of, things that I get to experiment with and try to address these challenges. But the, I kind of mentioned earlier, a case study that was shown at the JAMstack conference in New York, and certainly, events like that, we\u2019re starting to see best practices or industry practices and industry approaches being talked about at those kind of events. And certainly, I want to see more and work on more case studies to get in places like on Smashing Magazines, so that we can share this information much more readily.<\/p>\n<p><span>Phil Hawksworth:<\/span> I think, large companies and the enterprise space, is gradually adopting JAMstack, in different places, in different ways, but the world is still sloped to get out there, so I think, each time a company adopts it and shares their experience, we all get to learn from that. But I really want to see more and more of these case studies get published, so that we can lean particularly about how these kind of challenges are overcome.<\/p>\n<p><span>Vitaly:<\/span> Alright, so, then, maybe just the last question from me, because I always like to read questions. So, the JAMstack land, if you could change something, maybe there is something that you desperately would love to see, beyond deployments. Anything else that would be really making you very happy? That would make your day? What would that be? What\u2019s on your wishlist, for JAMstack?<\/p>\n<p><span>Phil Hawksworth:<\/span> What a question. I mean, had we not talked about incremental builds, that would be\u2014<\/p>\n<p><span>Vitaly:<\/span> We did. That\u2019s too late, now. This card has been passed, already. We need something else.<\/p>\n<p><span>Phil Hawksworth:<\/span> So\u2014<\/p>\n<p><span>Vitaly:<\/span> What I mean, like on a platform, if you looked at the back platform, there are so many exciting things happening. We have Houdini, we have web components coming, and everything, since you could be changing the entire landscape of all the right components. On the other side, we have all this magical, fancy world with SS NGS, and, of course, obviously, we also have single-page applications and all. What are you most excited about?<\/p>\n<p><span>Phil Hawksworth:<\/span> I\u2019m going to be obtuse here, because there is so much stuff that\u2019s going on, it\u2019s exciting, and there is so many new capabilities that you can make use of in the browser. The thing that I really get excited about is people showing restraint (laughs) and as I said, dull answer, but I love seeing great executions that are done with restraint, in a thoughtful \u2014 about the wider audience. It\u2019s really good fun, and gratifying to build with the shiniest new JavaScript library or the new browser API that does, I don\u2019t know, scratch and sniff capabilities in the browser, which we desperately need, any day now.<\/p>\n<p><span>Phil Hawksworth:<\/span> But I really like seeing things that I know are going to work in many, many places. They\u2019re going to be really performant, are going to be sympathetic to the browsers that exist \u2014 not just on the desks of CEOs and CTOs who got the snazzy toys, but also people who have got much lower-powered devices, or they\u2019ve got challenging network conditions and those kinds of things. I like seeing interesting experiences, and rich experiences, delivered in a way that are sympathetic to the platform, and kind of, compassionate for the wider audience, because I think the web reaches much further than us, the developers, who build things for it. And I get excited by seeing interesting things done, in ways that reach more people.<\/p>\n<p><span>Phil Hawksworth:<\/span> That\u2019s probably not the answer you were necessarily\u2014<\/p>\n<p><span>Vitaly:<\/span> Oh, that\u2019s a nice ending. Thank you so much. No, that\u2019s perfect, that really is. All right, I felt everything went good! Thank you so much for being with us! I\u2019m handing out to Scott!<\/p>\n<p><span>Phil Hawksworth:<\/span> Great!<\/p>\n<p><span>Vitaly:<\/span> I\u2019m just here to play questions and answers. So, thank you so much, Phil! I\u2019m still here, but Scott, the stage is yours, now! Maybe you can share with us what\u2019s coming up next on Smashing TV?<\/p>\n<p><span>Scott:<\/span> I will, but first, Phil, I can\u2019t wait to see how the implementation of scratch-and-sniff API work. Sounds very interesting. And, Vitaly, JAMstackify is already taken.<\/p>\n<p><span>Vitaly:<\/span> (dejected) Taken?! Can we buy it?<\/p>\n<p><span>Scott:<\/span> No, it exists!<\/p>\n<p><span>Vitaly:<\/span> Well, that\u2019s too late. I\u2019m always late.<\/p>\n<p><span>Phil Hawksworth:<\/span> That\u2019s exciting in its own way.<\/p>\n<p><span>Vitaly:<\/span> That\u2019s the story of my life. I\u2019m always late.<\/p>\n<p><span>Scott:<\/span> Members coming up next, I believe, Thursday, the 13th, we have my ol\u2019 pa, Zach Leatherman, talking about what he talks about best, which is fonts. So, he\u2019s talking about the Five Y\u2019s of Font Implementations. And then, I\u2019m also very interested in the one we have coming up on the 19th, which is editing video, with JavaScript and CSS, with Eva Faria. So, stay tuned for both of those.<\/p>\n<p><span>Scott:<\/span> So, that is again, next Thursday, with Zach Leatherman, and then on the 19th, with Eva, who will be talking about editing video in JavaScript and CSS. So, on that note, Phil, I can\u2019t see you anymore, are you still there?<\/p>\n<p><span>Phil Hawksworth:<\/span> I\u2019m here!<\/p>\n<p><span>Scott:<\/span> On that note, thank you very much everyone! Also, is anybody in the, kind of, close to Toronto area? Or anybody that\u2019s ever wanted to visit Toronto? We have a conference coming up at the end of June, and there\u2019s still a few tickets left. So, maybe we\u2019ll see some of you there.<\/p>\n<p><span>Vitaly:<\/span> Thank you so much, everyone else!<\/p>\n<p><span>Vitaly:<\/span> Oh, by the way, just one more thing! Maybe Phil mentioned it, but we also have the JAMstack Conference in London, in July. So, that\u2019s something to watch out for, as well. But I\u2019m signing off and going to get my salad! Not sure what you\u2014<\/p>\n<p><span>Scott:<\/span> Okay, goodbye, everybody!<\/p>\n<p><span>Vitaly:<\/span> All right, bye-bye, everyone.<\/p>\n<h3>That\u2019s A Wrap!<\/h3>\n<p>We kindly thank Smashing Members from the very bottom of our hearts for their continuous and kind support \u2014\u00a0and we can\u2019t wait to host more webinars in the future.<\/p>\n<p>Also, Phil will be MCing at <a href=\"https:\/\/smashingconf.com\/toronto-2019\/\">SmashingConf Toronto 2019<\/a> next week and at <a href=\"https:\/\/jamstackconf.com\/london\/\">JAMstack_conf<\/a> \u2014 we\u2019d love to see you there as well!<\/p>\n<p>Please do let us know if you find this series of interviews useful, and whom you\u2019d love us to interview, or what topics you\u2019d like us to cover and we\u2019ll get right to it.<\/p>\n<div data-component=\"FeaturePanel\" data-audience=\"non-subscriber\" data-remove=\"true\"><\/div>\n<div>\n  <img data-recalc-dims=\"1\" decoding=\"async\" src=\"https:\/\/i0.wp.com\/www.taterboy.com\/blog\/wp-content\/uploads\/2019\/06\/logo-red-14.png?w=900\" alt=\"Smashing Editorial\"><span>(ra, il)<\/span>\n<\/div>\n<\/article>\n<p class=\"wpematico_credit\"><small>Powered by <a href=\"http:\/\/www.wpematico.com\" target=\"_blank\">WPeMatico<\/a><\/small><\/p>\n","protected":false},"excerpt":{"rendered":"<p>JAMstack Fundamentals: What, What And How JAMstack Fundamentals: What, What And How Vitaly Friedman 2019-06-20T14:30:59+02:002019-06-21T11:06:17+00:00 We love pushing the boundaries on the web, and so we\u2019ve decided to try something new. You probably have heard of JAMstack \u2014 the new web stack based on JavaScript, APIs, and Markup \u2014 but what does it mean for&#8230;<a class=\"moretag\" href=\"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/\"> Read the full article&#8230;<\/a><\/p>\n","protected":false},"author":4,"featured_media":67131,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[371],"tags":[],"class_list":["post-67130","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-user-experience"],"aioseo_notices":[],"aioseo_head":"\n\t\t<!-- All in One SEO 5.0.0.1 - aioseo.com -->\n\t<meta name=\"description\" content=\"JAMstack Fundamentals: What, What And HowJAMstack Fundamentals: What, What And How Vitaly Friedman 2019-06-20T14:30:59+02:002019-06-21T11:06:17+00:00We love pushing the boundaries on the web, and so we\u2019ve decided to try something new. You probably have heard of JAMstack \u2014 the new web stack based on JavaScript, APIs, and Markup \u2014 but what does it mean for your workflow\" \/>\n\t<meta name=\"robots\" content=\"max-image-preview:large\" \/>\n\t<meta name=\"author\" content=\"Guest Contribution\"\/>\n\t<meta name=\"keywords\" content=\"user experience\" \/>\n\t<link rel=\"canonical\" href=\"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/\" \/>\n\t<meta name=\"generator\" content=\"All in One SEO (AIOSEO) 5.0.0.1\" \/>\n\t\t<meta property=\"og:locale\" content=\"en_US\" \/>\n\t\t<meta property=\"og:site_name\" content=\"Design for Immersive Technologies | User Experience for Games, Virtual Reality (VR) and Augmented\/Mixed Reality (AR\/MR)\" \/>\n\t\t<meta property=\"og:type\" content=\"article\" \/>\n\t\t<meta property=\"og:title\" content=\"JAMstack Fundamentals: What, What And How | Design for Immersive Technologies\" \/>\n\t\t<meta property=\"og:description\" content=\"JAMstack Fundamentals: What, What And HowJAMstack Fundamentals: What, What And How Vitaly Friedman 2019-06-20T14:30:59+02:002019-06-21T11:06:17+00:00We love pushing the boundaries on the web, and so we\u2019ve decided to try something new. You probably have heard of JAMstack \u2014 the new web stack based on JavaScript, APIs, and Markup \u2014 but what does it mean for your workflow\" \/>\n\t\t<meta property=\"og:url\" content=\"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/\" \/>\n\t\t<meta property=\"article:published_time\" content=\"2019-06-21T11:18:50+00:00\" \/>\n\t\t<meta property=\"article:modified_time\" content=\"2019-06-21T11:18:50+00:00\" \/>\n\t\t<meta name=\"twitter:card\" content=\"summary\" \/>\n\t\t<meta name=\"twitter:title\" content=\"JAMstack Fundamentals: What, What And How | Design for Immersive Technologies\" \/>\n\t\t<meta name=\"twitter:description\" content=\"JAMstack Fundamentals: What, What And HowJAMstack Fundamentals: What, What And How Vitaly Friedman 2019-06-20T14:30:59+02:002019-06-21T11:06:17+00:00We love pushing the boundaries on the web, and so we\u2019ve decided to try something new. You probably have heard of JAMstack \u2014 the new web stack based on JavaScript, APIs, and Markup \u2014 but what does it mean for your workflow\" \/>\n\t\t<script type=\"application\/ld+json\" class=\"aioseo-schema\">\n\t\t\t{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/#article\",\"name\":\"JAMstack Fundamentals: What, What And How | Design for Immersive Technologies\",\"headline\":\"JAMstack Fundamentals: What, What And How\",\"author\":{\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/author\\\/guestcontribution\\\/#author\"},\"publisher\":{\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/#organization\"},\"image\":{\"@type\":\"ImageObject\",\"url\":\"https:\\\/\\\/i0.wp.com\\\/www.taterboy.com\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/06\\\/logo-red-14.png?fit=60%2C80&ssl=1\",\"width\":60,\"height\":80},\"datePublished\":\"2019-06-21T04:18:50-07:00\",\"dateModified\":\"2019-06-21T04:18:50-07:00\",\"inLanguage\":\"en-US\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/#webpage\"},\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/#webpage\"},\"articleSection\":\"User Experience\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/#breadcrumblist\",\"itemListElement\":[{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog#listItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.taterboy.com\\\/blog\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/category\\\/user-experience\\\/#listItem\",\"name\":\"User Experience\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/category\\\/user-experience\\\/#listItem\",\"position\":2,\"name\":\"User Experience\",\"item\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/category\\\/user-experience\\\/\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/#listItem\",\"name\":\"JAMstack Fundamentals: What, What And How\"},\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog#listItem\",\"name\":\"Home\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/#listItem\",\"position\":3,\"name\":\"JAMstack Fundamentals: What, What And How\",\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/category\\\/user-experience\\\/#listItem\",\"name\":\"User Experience\"}}]},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/#organization\",\"name\":\"Design for Immersive Technologies\",\"description\":\"User Experience for Games, Virtual Reality (VR) and Augmented\\\/Mixed Reality (AR\\\/MR)\",\"url\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/author\\\/guestcontribution\\\/#author\",\"url\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/author\\\/guestcontribution\\\/\",\"name\":\"Guest Contribution\",\"image\":{\"@type\":\"ImageObject\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/#authorImage\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/d2aad73eb0f48c67b141e9fc978a0e498969791ed623346e361d02d19775b0bb?s=96&d=mm&r=g\",\"width\":96,\"height\":96,\"caption\":\"Guest Contribution\"}},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/#webpage\",\"url\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/\",\"name\":\"JAMstack Fundamentals: What, What And How | Design for Immersive Technologies\",\"description\":\"JAMstack Fundamentals: What, What And HowJAMstack Fundamentals: What, What And How Vitaly Friedman 2019-06-20T14:30:59+02:002019-06-21T11:06:17+00:00We love pushing the boundaries on the web, and so we\\u2019ve decided to try something new. You probably have heard of JAMstack \\u2014 the new web stack based on JavaScript, APIs, and Markup \\u2014 but what does it mean for your workflow\",\"inLanguage\":\"en-US\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/#website\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/#breadcrumblist\"},\"author\":{\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/author\\\/guestcontribution\\\/#author\"},\"creator\":{\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/author\\\/guestcontribution\\\/#author\"},\"image\":{\"@type\":\"ImageObject\",\"url\":\"https:\\\/\\\/i0.wp.com\\\/www.taterboy.com\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/06\\\/logo-red-14.png?fit=60%2C80&ssl=1\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/#mainImage\",\"width\":60,\"height\":80},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/2019\\\/06\\\/jamstack-fundamentals-what-what-and-how\\\/#mainImage\"},\"datePublished\":\"2019-06-21T04:18:50-07:00\",\"dateModified\":\"2019-06-21T04:18:50-07:00\"},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/\",\"name\":\"Design for Immersive Technologies\",\"description\":\"User Experience for Games, Virtual Reality (VR) and Augmented\\\/Mixed Reality (AR\\\/MR)\",\"inLanguage\":\"en-US\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.taterboy.com\\\/blog\\\/#organization\"}}]}\n\t\t<\/script>\n\t\t<!-- All in One SEO -->\n\n","aioseo_head_json":{"title":"JAMstack Fundamentals: What, What And How | Design for Immersive Technologies","description":"JAMstack Fundamentals: What, What And HowJAMstack Fundamentals: What, What And How Vitaly Friedman 2019-06-20T14:30:59+02:002019-06-21T11:06:17+00:00We love pushing the boundaries on the web, and so we\u2019ve decided to try something new. You probably have heard of JAMstack \u2014 the new web stack based on JavaScript, APIs, and Markup \u2014 but what does it mean for your workflow","canonical_url":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/","robots":"max-image-preview:large","keywords":"user experience","webmasterTools":{"miscellaneous":""},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/#article","name":"JAMstack Fundamentals: What, What And How | Design for Immersive Technologies","headline":"JAMstack Fundamentals: What, What And How","author":{"@id":"https:\/\/www.taterboy.com\/blog\/author\/guestcontribution\/#author"},"publisher":{"@id":"https:\/\/www.taterboy.com\/blog\/#organization"},"image":{"@type":"ImageObject","url":"https:\/\/i0.wp.com\/www.taterboy.com\/blog\/wp-content\/uploads\/2019\/06\/logo-red-14.png?fit=60%2C80&ssl=1","width":60,"height":80},"datePublished":"2019-06-21T04:18:50-07:00","dateModified":"2019-06-21T04:18:50-07:00","inLanguage":"en-US","mainEntityOfPage":{"@id":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/#webpage"},"isPartOf":{"@id":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/#webpage"},"articleSection":"User Experience"},{"@type":"BreadcrumbList","@id":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/#breadcrumblist","itemListElement":[{"@type":"ListItem","@id":"https:\/\/www.taterboy.com\/blog#listItem","position":1,"name":"Home","item":"https:\/\/www.taterboy.com\/blog","nextItem":{"@type":"ListItem","@id":"https:\/\/www.taterboy.com\/blog\/category\/user-experience\/#listItem","name":"User Experience"}},{"@type":"ListItem","@id":"https:\/\/www.taterboy.com\/blog\/category\/user-experience\/#listItem","position":2,"name":"User Experience","item":"https:\/\/www.taterboy.com\/blog\/category\/user-experience\/","nextItem":{"@type":"ListItem","@id":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/#listItem","name":"JAMstack Fundamentals: What, What And How"},"previousItem":{"@type":"ListItem","@id":"https:\/\/www.taterboy.com\/blog#listItem","name":"Home"}},{"@type":"ListItem","@id":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/#listItem","position":3,"name":"JAMstack Fundamentals: What, What And How","previousItem":{"@type":"ListItem","@id":"https:\/\/www.taterboy.com\/blog\/category\/user-experience\/#listItem","name":"User Experience"}}]},{"@type":"Organization","@id":"https:\/\/www.taterboy.com\/blog\/#organization","name":"Design for Immersive Technologies","description":"User Experience for Games, Virtual Reality (VR) and Augmented\/Mixed Reality (AR\/MR)","url":"https:\/\/www.taterboy.com\/blog\/"},{"@type":"Person","@id":"https:\/\/www.taterboy.com\/blog\/author\/guestcontribution\/#author","url":"https:\/\/www.taterboy.com\/blog\/author\/guestcontribution\/","name":"Guest Contribution","image":{"@type":"ImageObject","@id":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/#authorImage","url":"https:\/\/secure.gravatar.com\/avatar\/d2aad73eb0f48c67b141e9fc978a0e498969791ed623346e361d02d19775b0bb?s=96&d=mm&r=g","width":96,"height":96,"caption":"Guest Contribution"}},{"@type":"WebPage","@id":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/#webpage","url":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/","name":"JAMstack Fundamentals: What, What And How | Design for Immersive Technologies","description":"JAMstack Fundamentals: What, What And HowJAMstack Fundamentals: What, What And How Vitaly Friedman 2019-06-20T14:30:59+02:002019-06-21T11:06:17+00:00We love pushing the boundaries on the web, and so we\u2019ve decided to try something new. You probably have heard of JAMstack \u2014 the new web stack based on JavaScript, APIs, and Markup \u2014 but what does it mean for your workflow","inLanguage":"en-US","isPartOf":{"@id":"https:\/\/www.taterboy.com\/blog\/#website"},"breadcrumb":{"@id":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/#breadcrumblist"},"author":{"@id":"https:\/\/www.taterboy.com\/blog\/author\/guestcontribution\/#author"},"creator":{"@id":"https:\/\/www.taterboy.com\/blog\/author\/guestcontribution\/#author"},"image":{"@type":"ImageObject","url":"https:\/\/i0.wp.com\/www.taterboy.com\/blog\/wp-content\/uploads\/2019\/06\/logo-red-14.png?fit=60%2C80&ssl=1","@id":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/#mainImage","width":60,"height":80},"primaryImageOfPage":{"@id":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/#mainImage"},"datePublished":"2019-06-21T04:18:50-07:00","dateModified":"2019-06-21T04:18:50-07:00"},{"@type":"WebSite","@id":"https:\/\/www.taterboy.com\/blog\/#website","url":"https:\/\/www.taterboy.com\/blog\/","name":"Design for Immersive Technologies","description":"User Experience for Games, Virtual Reality (VR) and Augmented\/Mixed Reality (AR\/MR)","inLanguage":"en-US","publisher":{"@id":"https:\/\/www.taterboy.com\/blog\/#organization"}}]},"og:locale":"en_US","og:site_name":"Design for Immersive Technologies | User Experience for Games, Virtual Reality (VR) and Augmented\/Mixed Reality (AR\/MR)","og:type":"article","og:title":"JAMstack Fundamentals: What, What And How | Design for Immersive Technologies","og:description":"JAMstack Fundamentals: What, What And HowJAMstack Fundamentals: What, What And How Vitaly Friedman 2019-06-20T14:30:59+02:002019-06-21T11:06:17+00:00We love pushing the boundaries on the web, and so we\u2019ve decided to try something new. You probably have heard of JAMstack \u2014 the new web stack based on JavaScript, APIs, and Markup \u2014 but what does it mean for your workflow","og:url":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/","article:published_time":"2019-06-21T11:18:50+00:00","article:modified_time":"2019-06-21T11:18:50+00:00","twitter:card":"summary","twitter:title":"JAMstack Fundamentals: What, What And How | Design for Immersive Technologies","twitter:description":"JAMstack Fundamentals: What, What And HowJAMstack Fundamentals: What, What And How Vitaly Friedman 2019-06-20T14:30:59+02:002019-06-21T11:06:17+00:00We love pushing the boundaries on the web, and so we\u2019ve decided to try something new. You probably have heard of JAMstack \u2014 the new web stack based on JavaScript, APIs, and Markup \u2014 but what does it mean for your workflow"},"aioseo_meta_data":{"post_id":"67130","title":null,"description":null,"keywords":null,"keyphrases":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_custom_url":null,"og_image_custom_fields":null,"og_custom_image_width":null,"og_custom_image_height":null,"og_video":null,"og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema_type":null,"schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":null,"robots_max_videopreview":null,"robots_max_imagepreview":"large","priority":null,"frequency":null,"location":null,"local_seo":null,"created":"2021-02-07 19:22:36","updated":"2026-09-01 12:34:09","focus_keyword":null,"additional_keywords":null,"truseo_locale":null,"primary_term":null,"og_image_url":null,"og_image_width":null,"og_image_height":null,"twitter_image_url":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"Article","isEnabled":true},"graphs":[]},"limit_modified_date":false,"ai":null,"breadcrumb_settings":null,"seo_analyzer_scan_date":null},"aioseo_breadcrumb":"<div class=\"aioseo-breadcrumbs\"><span class=\"aioseo-breadcrumb\">\n\t\t\t<a href=\"https:\/\/www.taterboy.com\/blog\" title=\"Home\">Home<\/a>\n\t\t<\/span><span class=\"aioseo-breadcrumb-separator\">&raquo;<\/span><span class=\"aioseo-breadcrumb\">\n\t\t\t<a href=\"https:\/\/www.taterboy.com\/blog\/category\/user-experience\/\" title=\"User Experience\">User Experience<\/a>\n\t\t<\/span><span class=\"aioseo-breadcrumb-separator\">&raquo;<\/span><span class=\"aioseo-breadcrumb\">\n\t\t\tJAMstack Fundamentals: What, What And How\n\t\t<\/span><\/div>","aioseo_breadcrumb_json":[{"label":"Home","link":"https:\/\/www.taterboy.com\/blog"},{"label":"User Experience","link":"https:\/\/www.taterboy.com\/blog\/category\/user-experience\/"},{"label":"JAMstack Fundamentals: What, What And How","link":"https:\/\/www.taterboy.com\/blog\/2019\/06\/jamstack-fundamentals-what-what-and-how\/"}],"jetpack_publicize_connections":[],"jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p8wzr5-hsK","jetpack_featured_media_url":"https:\/\/i0.wp.com\/www.taterboy.com\/blog\/wp-content\/uploads\/2019\/06\/logo-red-14.png?fit=60%2C80&ssl=1","_links":{"self":[{"href":"https:\/\/www.taterboy.com\/blog\/wp-json\/wp\/v2\/posts\/67130","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.taterboy.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.taterboy.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.taterboy.com\/blog\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/www.taterboy.com\/blog\/wp-json\/wp\/v2\/comments?post=67130"}],"version-history":[{"count":0,"href":"https:\/\/www.taterboy.com\/blog\/wp-json\/wp\/v2\/posts\/67130\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.taterboy.com\/blog\/wp-json\/wp\/v2\/media\/67131"}],"wp:attachment":[{"href":"https:\/\/www.taterboy.com\/blog\/wp-json\/wp\/v2\/media?parent=67130"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.taterboy.com\/blog\/wp-json\/wp\/v2\/categories?post=67130"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.taterboy.com\/blog\/wp-json\/wp\/v2\/tags?post=67130"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}