The Long-Term Strategy of Composable Software

Composable Software

What Are We Talking About Here?

Building Blocks.

I said it was like Node Package Manager (NPM), but for non-developers. If you’re not familiar with it, NPM is a software registry with over 800,000 code packages. Software developers use NPM to share open source software and many organizations use it to manage their development projects.

In basic terms, it’s a catalog of libraries and code packages where each provide completed functionality that you can integrate into your application. For example, if you want to build a draggable card layout for an interface, there’s a number of packages that do it for you.

NPM is a massive bucket of building blocks and it’s been around since 2009.

Enter Low-Code/No-Code

Low-code/no-code platforms are popping up everywhere making bold promises to aspiring application builders that they can build their applications without having to learn to code.

And that’s true, you can.

But the problem with these platforms is that they create a tension between wanting to give non-developers the power to build and wanting to give developers the power to extend and customize, which I talk about here.

A lot of these new platforms have favored non-developers at the cost of binding users into the platform’s ecosystem that tie the hands of developers to narrow technology stacks, force them to maintain the applications with limited control, and hinder their ability to implement customizations. In addition, businesses are beholden to scaling pricing structures that can balloon into big fees as usage increases.

Businesses that commit to building on one of them often discover later on that they have unwittingly pledged fealty to the lord of no-code.

Backing out and changing course is costly and time-consuming. It’s the low-code/no-code hangover.

BUT, what if there was an NPM for low-code/no-code building blocks?

Composable Software Platforms

This is essentially what the goal is of the composable software platform. According to this article, the promised benefits would include:

  • Flexibility to build and adapt (similar to the standard fare of low-code/no-code tools)
  • Accelerated development with reusability
  • Seamless scalability
  • Easy integrations
  • Better future-proofing of your applications
  • Modular in nature, giving organizations greater control of their software development process, data, and roadmap

And would require:

  • Using microservices
  • Relying on APIs extensively
  • Leveraging event-driven architecture
  • Being an integration platform
  • Providing composable asset frameworks to enable developers to build the building blocks

The article doesn’t specifically mention “low-code” or “no-code” composability as the goal of composable software platforms, but when the author says “composable development frameworks abstract away the complexity of building composable systems,” it’s important to point out that low-code and no-code ARE methods of abstraction, and they’re gaining popularity.

In order to achieve it, the industry has to take a step back and re-prioritize developers. Ultimately, they’re the ones that will support and maintain whatever tools and applications are being built because underneath every low-code/no-code tool is…code.

Composable software enables developers to programmatically customize the customizable parts. As I’ve said before, the execution behind the execution. As The Thin, Composable Software Platform, Embedded In Your Environment


These are the miniature applications within a larger application that zero in on specific functionalities. They are independent and self-contained.’s form builder is the user interface to build forms and data model resource endpoints to connect to microservices. Developers only need to build integrated, internal microservices once OR integrate with third-party microservices once, then non-developers can continually use  them in different ways.


Application Protocol Interfaces (APIs) enable communication and interaction between different components.

With, APIs are generated automatically via drag and drop as forms and resources are built using the form builder. Every form has an API endpoint, the submissions have an API, and individual submissions have an endpoint.

Event-Driven Architecture

Components need to communicate and react to events asynchronously, aka “loose coupling.”

Programmatic OR user-based event-driven form actions in facilitate data routing to accomplish various workflows—triggered on submissions.

Integration Platforms

These are basically the infrastructure and tools used to manage software components. is a thin, middleware software layer that manages forms and resource data models, API integrations, data routing, and connects disparate system data. Since everything is an API, lets you connect to internal systems, legacy systems, third-party systems, and systems on premise or in the cloud.

Composable Developer Frameworks

A composable developer framework would provide developers the pre-built tools, modules, and APIs to build composable applications. is software that builds reusable form and resource data model components with a drag and drop layer of abstraction. Given the familiar nature of the form UI and the ease of use with drag and drop, it’s not just developers who can build composable software, but non-developers as well.

What’s The Result?

It’s the kind of environment where developers will be focused on building the building blocks, configuring integrations, and maintaining both. They’ll maintain control of their development roadmaps and data, they won’t be forced to support code that isn’t their own, they’ll be able to extend and customize without hindrances, and nor will they be locked into a tech stack for the rest of their application.

The building blocks will populate a catalog of reusable components that power users will assemble to design workflows that achieve business goals. This environment shifts more of the cognitive load of developing software systems that achieve business goals away from developers and into the heads of the business stakeholders themselves.

And when it comes to scaling, it’s a matter of adding more building blocks and more power users who build. And if usage goes up, the cost remains the same.

Composable Software Is Like NPM For Non-Developers. It Enables Them To Assemble Independent, Self-Contained Units Of Functionality Into Usable Applications.

Published by Wizard is a zero-trust, data governance strategy platform, embedded in your environment, that enables you to build business process workflow applications or anything that uses forms with lightning bolt speed. is unique in its reach to the application layer regarding governance because we acknowledge forms are the primary entry point into everything data related. Forms are the UI, forms are the data model, and forms are the API model.

LighthouseHQ Case Study: Digital Transformation
Get Answers

Need More Answers?

Ask and we'll get back with you in 1 business day.

Contact Us

Send us a message to contact support or ask a question.

Schedule a meeting

Open Source Platform

Read our FAQ to find out what exactly is Open Source

View the Platform Documentation

View the API Documentation

View the Open Source Code

Learn More

Learn How It Works

Read the Release Notes

Discover Industries that use

Read our Blog