So you want to build the next great app for your global enterprise or to launch your start-up. You’re going to need some help with that.

There’s no such thing as a freestanding, self-contained, or isolated application anymore. Remember shrink-wrapped software? Exactly.

To build even the simplest application — and certainly to build anything enterprise-grade — takes, if not a village, a high degree of interconnectivity. Hence, the importance of low-code principle #5:

An enterprise application development platform needs to be open so that anything can be integrated and there are no limitations to what can be built.

There is absolutely no point in a platform that doesn’t keep all your options open. You need to connect with all the resources it takes to create your magnum appus. You need to interface fully with whatever technology landscape you travel in. That’s why openness is a fundamental principle of low-code.

There’s open, and there’s really open

“Open” means different things to different people. “Open source” is a universal and much-loved form of software licensing as well as a culture of free intellectual exchange. “Open systems” implies interoperability and open standards in a software environment. Non-technically speaking, open implies transparency, accessibility, and connectability.

A proper low-code platform calls for openness of every type in every direction — horizontally and vertically, backwards and forwards, inside and out — to accommodate every imaginable need or development. To succeed in complex and wide-ranging landscapes, low-code has to meld effortlessly with core and legacy systems even as it incorporates brand new technologies to push the envelope of the possible.

True openness is the ruling principle that keeps the low-code platform from ever becoming obsolete, future-proofing it to gracefully adopt and incorporate all the next-great-things that have yet to be conceived.

Connecting with all the possibilities

If we had to invent everything ourselves or build everything from scratch, our ability to incorporate cutting-edge innovation in our applications would be severely constricted. How would we assemble the mountains of data needed to teach facial recognition algorithms? How could we afford the computing infrastructure to power sophisticated artificial intelligence processes or engaging augmented reality experiences? How do we accommodate blockchain? And what about connecting to whatever IoT “thing” an app needs to connect to — toaster, car, temperature-sensitive pharmaceutical shipment, assembly-line robot, or piece of vital biomedical equipment?

How do we do that?

By being open to the possibilities. It just requires the right connections.

A low-code platform (or, truly, any viable platform) needs to be architected to accommodate anything it needs to connect to. The good news is that a lot of developers have to make similar connections, so somebody else may have already built a connector to do what’s needed. That’s where the community comes in.

I’m anticipating the ninth principle here, “Community,” but as becomes apparent in these posts, the principles are all intertwined. Communities spring up around every major technology movement, and low-code is no exception. Open technologies with open communities mean collective brainpower is at everyone’s disposal. The concentric circles of community — within the enterprise, then in the low-code sphere, then in the tech world at large — put a lot of ‘amazing’ within reach. Low-code makes it easy to tap into it.

Low-code also makes it exceptionally easy to build new connectors when needed, the same way it makes everything easy to build.

The practical pathways to openness

The tools that make it possible for low-code applications to connect to everything are familiar. APIs and SDKs are the mainstays, supporting open models, open data, and application and platform extensibility. And for that occasion when there’s a need for a highly specialized connector, there is always the possibility to…write code. (Because even a low-code platform, to be truly open, has to allow for and accommodate that possibility.)

Extensibility is openness in practice. Those custom connectors mentioned above are a big part of extensibility — if there’s something the basic low-code model can’t accommodate, if you really need to custom-code a feature or function or incorporate any kind of Java action (for example), if you need to deal with the nuances and idiosyncrasies of existing/legacy enterprise applications, if you need to leverage other apps or app services — whatever you want to do, low-code offers elegant, easy, and open means of extending the model to achieve it.

There are more detailed and somewhat more technical explanations on our website for how Mendix enables openness and extensibility, and how we make it possible to integrate with anything, including your favorite existing tools. These are great examples of how a low-code platform can and should adhere to the principle of openness.

Make it smart

Openness in low-code is a pretty exciting concept, because it makes it so easy to connect to and incorporate any resources you need. But as we sit here in 2020, where the excitement really ratchets up is around building smart applications. Those ideas mentioned above — AI, augmented reality, edge computing, and more — depend on the ability to integrate with all kinds of data and resources, including from the likes of Google, IBM, Facebook and more. Concepts like digital twins, connected factories, and all manner of innovations that depend on ingesting, crunching, and analyzing vast quantities of data and then shaping algorithms and triggering responses — low-code makes them accessible and achievable in the here and now without requiring a cohort of coding geniuses.

Open to a world of possibilities

To sum up low-code principle #5, openness: Applications need to easily integrate with existing legacy systems and also accommodate new technologies as they emerge. Smart apps require connections with vast data resources, all manner of sensors, external AI capabilities, edge computing, and other technologies that enable applications to be ever-more relevant, contextual, proactive, intelligent, and generally adaptive to the needs of users.

When you’re open to everything, everything is possible!