Updated: Aug 24
Let’s talk about the history of software.
In the early days, computers ran programs that were 1) self-contained and 2) imperative. This means that every program was contained in its entirety on the computer, and that the computer would execute each instruction in order, like following the steps of a recipe. As we got better at writing and maintaining software, we realized that instead of writing a step by step program recipe, it was much easier to create bite-sized pieces of code that each performed a specific function. Then, we can combine each of these small functions into a full program. This is the principle behind functional programming.
This approach has several advantages. First, functional programs are modular. It’s much easier to make a small change without messing up the whole program. Second, functional code is more readable, and thus easier to maintain. It’s much easier to understand what a small, bite-sized function is trying to do rather than try to decipher the effect of a single instruction in an unbroken two thousand line program. Functional programming also makes programs simpler, because you can re-use a single function several times in a single program, and more secure, because you can control exactly how much power and access each function has.
Then, with the advent of the Internet, programs no longer had to be self-contained. The late 1990’s and early 2000’s saw the rise of the Application Programming Interface, or API. The idea of the API is powerful and simple: it’s a standard way for different applications to talk to one another. But it was the beginning of a new era in software. Now, instead of creating everything from scratch yourself, you could build your application through APIs from different building blocks that you know already work. APIs take the idea of simple, modular programs introduced with functional programming, and bring it to the next level. For example, let’s say you wanted to write a dictation software for meetings. Instead of spending time and energy rewriting a speech-to-text ML algorithm, just leverage the thousands of engineers Google has used to build their API, and focus on the special sauce that will make your application stand out from the rest.
Headless commerce is exciting to those in the e-commerce software space because all the power and flexibility of the API has arrived in the world of e-commerce. Headless commerce platforms like Shopify allow merchants to specialize and focus on what they do best: selling products. Meanwhile, merchants can quickly and seamlessly outsource hard problems like payments to companies like Stripe, who have put thousands of hours into their payments API, or Everyware, who have a pay-by-text product that can be seamlessly integrated into the point of sale. The result is that it’s easier than ever to start an online e-commerce business. Even legacy retailers are finding that with the powerful tools available in the Shopify ecosystem, their online sales are becoming an ever growing portion of their revenue. And the real power of headless commerce is the virtuous cycle of a growing marketplace: as everyone moves online, more vendors create powerful tools for merchants to use, which draws even more merchants to the platform.
But the most exciting thing about headless commerce is that despite billion dollar players like Shopify dominating the space, the problem hasn’t been solved yet. Many brands and retailers, especially mid-market retailers and non-traditional D2C brands, don’t yet have a solution that fits their needs. But there are many new startups trying to capitalize on this huge opportunity. Sierra Ventures recently invested in Fabric, a new up-and-coming player in the space. In our own Atlanta backyard, Makeswift is approaching the problem from a different angle: building fast, lightweight websites using the same modular approach that makes headless commerce so versatile. Headless commerce is powering a fundamental shift in the way businesses sell products, and we can’t wait to see what comes next.