Start of Main Content

Composable architecture is not a new concept. Development teams who were around in the early 2000s will tell you how painful some of the major vendor programming solutions were. But there was hope from the Java community. I followed Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (the gang of four), Martin Fowler, Robert Martin, and others who opened our minds to design patterns, including composable ones.

I remember reading a Martin Fowler article named Microservices. In the article, he mentioned an industry desire to build systems by plugging together components. These components are units of software that are independently replaceable and upgradeable and often backed by microservices or are microservices themselves. That article reinforced the idea that software could be composable. For the record, Jonathan Murray coined the term “composable” in a blog post in 2013. However, I wasn’t exposed to him until much later.  

Composability within a complete, strong type language or compiled application using languages like Java or .NET is also not new. Sometimes, these applications are called monoliths partially because all the features tend to run in the same application domain. For example, Inversion of Control containers was introduced to manage dependencies and create a form of composability. Microsoft introduced the Managed Extensibility Framework over a decade ago. That framework allowed developers to inject and extend functionality.  

Often, when composable architecture is discussed today, it includes the definition that the units of software are independent. This is not true in a monolith. Most monoliths are created using a language that uses a compiler. A key challenge to these frameworks is managing their dependencies because they create a bond based on their versions and the relationship to those versions. However, the compiler comes with a great benefit. The compiler creates the ability to know that the code will work together. It also allows tooling within an Integrated Development Environment, creating high levels of productivity, quality, and language enhancements. This productivity led to larger applications, longer maintenance cycles due to their size, and eventually, a rethink that we should be doing composability in JavaScript, a dynamic typing language often called duck type. 

One of the simplest components I remember implementing that you could genuinely plug into a website was Omniture (now Adobe Analytics), an analytics package. If you’re on a team that develops and/or manages a site, then you know that replacing an analytics package is something you can do within a reasonable time frame. In the early 2000s, it was as simple as changing a JavaScript reference. That started the trend of many companies offering products you could use by simply adding a JavaScript file to your website.  

In 2023, we’re at a point where many of the top content management system (CMS) vendors are updating their products to offer their CMSs with a composable architecture combined with JavaScript as the primary language. This is often called a headless or SaaS-only CMS, which can be accessed via an API or microservice. This vastly differs from the traditional CMS platform, which includes the delivery layer, whose primary function is creating your webpage with the content before it leaves the web server.  

Why would you want to move to a headless CMS? I’ll explain the common pros and cons of a headless CMS in a composable architecture to help you decide if you should make the switch. 

Flexibility via a Composable Architecture 

  • Pro: A headless CMS in a composable architecture offers unparalleled flexibility. Developers can compose a tailored tech stack, selecting the best tools for specific tasks, resulting in a more agile and adaptable system. 
  • Con: This flexibility may introduce complexity, requiring a skilled development team to integrate and manage the diverse components effectively. 

Understand the pros and cons of implementing a headless CMS. 

We’ll walk you through all the factors you should consider when deciding whether to switch to a headless CMS. If you want to make the change, we can help you implement a headless CMS and make the most of it.


  • Pro: Composable architectures with headless CMSs allow for seamless scalability. Your organization can scale individual components independently, optimizing resources based on specific needs. 
  • Con: Scaling may require careful orchestration and management, potentially increasing operational overhead. 

Technology Diversity 

  • Pro: Adopting a headless CMS promotes technology diversity, enabling your developers to leverage the latest tools and frameworks for frontend and backend components.  
  • Con: Managing a diverse technology stack may pose compatibility, versioning, and maintenance challenges.  

Should you move to a headless CMS? If your pros outweigh the cons, then you should consider it. You should also conduct a thoughtful evaluation of the unique requirements and priorities driving your content management strategy to see if it’s the right fit. Regardless of whether you go headless with your CMS, you should be moving towards a composable architecture for your website because composable architecture is the way of the future. 

Want more guidance on whether a headless CMS is right for your organization? Contact us. We can help you better understand the pros and cons, help you implement a headless CMS, and help you make the most of the opportunities it provides.


Latest Ideas

Take advantage of our expertise with your next project.