Low-code development combats microservices complexity
Microservices should simplify software development. In theory, we can stitch microservices together with a top layer, assembling applications out of components. The promise isn’t new, but it is worth examining.
Ivar Jacobson proposed the idea of software components, like circuit-board components, in 1967. He wanted to make building software more like assembling prefabricated blocks of code and less like creating everything from scratch. Yet, something happens every time we get close to Jacobson’s component dream. The components require new layers of complexity. In microservices, this means additional programming to ensure uptime, reliability and observability. We aim for easy-to-assemble building blocks, but end up with a great deal of code in reality.
One emerging alternative that knocks out the microservices complexity problem is low-code development, a way to turn actions and data into applications with minimal conventional programming. In some ways, microservices and low-code development solve similar problems. Low-code development platforms emerged as a way to build apps with out-of-the-box, standardized components, using prebuilt templates. Low-code does not provide the development sophistication of microservices. It can, however, work in situations where managing microservices leads to more effort than the benefit promised by that architecture.
Once software developers and architects understand these microservices complexity issues, they can determine how and when low-code development platforms provide a viable workaround.
Microservices’ code, resiliency and uptime problems
Microservices independently communicate with one another over internet standards, which is what makes the architecture powerful. Because they speak TCP/IP and deliver data payloads in JSON, the components can fit into each other without dependencies. These small services each perform one task well. A company can have a set of services for customer information, another for product lookup, a third for orders and a fourth for delivery.
But breaking things down along business functions means there’s a lot of code to manage. When something goes wrong, there may be an entire chain of events to debug. Microservices requires logging and monitoring work that exists outside the idea of simple components, and creates an explosion of code.
When something goes wrong, figuring out which component contributed to the issue can be tricky without the right tools — which, again, means more code. While each service has high uptime in this supported deployment, resilience and reliability at the code level start to crumble.
The alternative in low-code
With low-code development, the platform builds and delivers the building blocks for an application.
The developers, or even business unit representatives, provide the variables, database connection, formatting and styling, and the tool generates the application, sometimes via a drag-and-drop UI. Provide the data, and a low-code development platform can even build a database. This is, in effect, the opposite approach to microservices, where you provide the database, abstract it into a service, and code the service logic.
Low-code development platforms generally reuse a great deal of common code. There is a massive reduction in lines of code, perhaps even hundreds to one. There are also fewer independent components, which are tightly coupled to each other. Each line of code becomes more powerful and traceable.
The simple example of a low-code development platform might be a database with a Create, Read, Update andDelete (CRUD) front end. A programmer can sketch out the table visually and fill in data through a simple spreadsheet. Users can access the data through the CRUD front end, which lives in an application that the platform generates, and can be downloaded from an app store.
A low-code platform does nearly everything that conventionally is coded for an application; most of the work for adopters is in tool configuration. As long as the app is simple, clean and doesn’t require many integration points, a low-code development platform might be the right alternative to a more complex microservices build. Low-code builds are an easy choice for applications that don’t need to integrate with other databases or that use a series of small tables. Examples include conference apps or one-time marketing promotions that run with user ID information.
Low-code development does not replace microservices. Once you need to share information between applications, in real time, microservices become the right strategy. But the low-code approach helps developers steer clear of over-engineering apps that don’t need it.