The Enterprise App Cloud: Unleashing Business Agility with the Power of 100% Data-Defined Development

By Bassam Chapatini, CTO at Unqork

I. Introduction

When ordering milk on a grocery delivery site, you can select exactly the item you want in just a few seconds via a series of drop-down menus—the brand, the source (almond, oat, cow), the quantity, the number of items, the fat content, etc. In other words, you use structured data. 

Now imagine putting all that information in an email, i.e. using unstructured data. It would obviously take longer to write the email, and longer for the shopper to search for your email and decipher exactly what you want. 

But you don’t just waste time. You also exponentially increase the chances of your order going wrong. Maybe you forget the name brand you prefer, or accidentally misspell it. Maybe the store doesn’t even carry that brand. Maybe the shopper misses the fact that you wanted oat milk instead of cow’s milk.  

Given all the ways unstructured data can go awry, why would you ever write an email when you could use a dropdown menu instead? And yet, enterprises are still developing software with unstructured, language-based code (and that includes low-code and no-code platforms, as we explain below)—the equivalent of the slow, error-prone email approach to ordering groceries. 

However, there is a new development paradigm that shares the speed and precision of the structured, drop-down menu approach. In this white paper, we explain why an unstructured, code-based approach to development is no longer necessary and how the Unqork Enterprise App Cloud: 

• Transforms all software components into 100% structured data—no code required, ever. 
• Dramatically speeds and simplifies the entire SDLC. 
• Helps creators focus on innovation and value creation, because the Enterprise App Cloud handles security, compliance, upgradeability, and more—all on an ongoing basis.

II. What is 100% data-defined development? 

The best way to understand the Enterprise App Cloud is to compare it with a technology that is already familiar—cloud computing. Essentially, it is to application development what the cloud is to hardware. They both provide a strategic layer of abstraction that enables much faster innovation, more flexible resource usage, and economies of scale. 

Think about computing before the cloud. Enterprises were in the business of buying, implementing, and managing computing hardware. True, over the years all kinds of incremental innovations made the job incrementally easier, from layouts that optimized cooling to the virtualization of servers to increase utilization. But managing servers was still hard work requiring a high level of skills. And every enterprise was doing it.

Cloud changed all that. Cloud computing took advantage of all those incremental innovations in server management, but it went one step further by completely abstracting the hardware layer, and thus making a hardware problem becomes something easily manageable through software. That means enterprises can get rid of their servers altogether—and the time, expense, and complexity of running a homegrown data center. 

If you ask a technology leader today what kinds of servers their organization’s applications are running on, chances are they have no idea. And even if they do know, the cloud provider could spin up an entirely different set of servers tomorrow. And their customers would never even know. 

Nor do they need to know. Their applications would run just like they do today—without any changes.

Yet if you ask them what type of code their organization is running, chances are they will spell out their entire stack—React, Angular, Java, Python, PostgreSQL, and the names will keep flowing. No wonder 80% of technology budgets go into Keeping the Lights On (KTLO), i.e. managing legacy code that is brittle, subject to security risks, hard to scale, and very expensive to maintain.  

The cloud promised freedom from hardware, data management, and complexity. It delivered—but not at the application layer. The fact is, businesses still create, secure, and manage applications as they did pre-cloud. More than ever, they need a new approach to create, secure, and maintain their applications in the cloud.

That is exactly what the Enterprise App Cloud powered by 100% data-defined development achieves. Suddenly, all those languages—and the costs, risk, and complexity they entail—become as irrelevant to the enterprise as servers are.  And businesses can redirect all those resources to unleashing business agility instead. 

From low-code/no-code to the Enterprise App Cloud

The abstraction that makes the Enterprise App Cloud possible can be traced almost as far back as computing itself. The first basic coding languages were just shorthand—i.e. a layer of abstraction—that let developers more easily manipulate the 1’s and 0’s on which all computing depends. 

As software has become more complex, coding languages have evolved and proliferated, with new languages at higher levels of abstraction able to do evermore complex and/or highly specific functions. However, each language then requires its own runtime to translate that language back into 1s and 0s to do what they are supposed to do.

Like server management tools, an array of tools simplify coding. APIs provide an interface that hides (and translates) the code behind a data specification. Security capabilities have been consolidated around protocols that can be specified through parameters. Front-end frameworks like React create components that are pieces of JavaScript hidden behind data specs. And of course, low-code platforms enable developers to select capabilities visually, which the platform then translates into code. 

From programming languages to security protocols and APIs, these new technologies have made the work of development incrementally easier. However, the demand for evermore complex apps have outstripped their power to simplify. And so, most tech departments still spend a huge portion of their time writing, testing, securing, managing, and updating code.

III. How the Enterprise App Cloud powered by 100% data-defined development works

So how does the Enterprise App Cloud change the equation? Again, the analogy to the cloud is very apt.  

Cloud computing absorbed all the great technologies that made it easier to run on-premise data centers, packaging them all up and delivering computing as a service. The Enterprise App Cloud that is powered by 100% data-defined development does the same thing for development. It leverages all those technologies that abstract away the work of writing code. And then it goes one step further, making it possible to create sophisticated, enterprise-grade software without having to write or manage a single line of code (LOC)—ever. 

Two things make this possible: 

1. The Enterprise App Builder. First, the Enterprise App Builder unifies the entirety of an application in a single structured, data-defined definition, including everything from input fields, UI layouts, and logic/rules engines to ETLs, integrations/services, and data stores.
2. The Enterprise App Cloud Services (runtime). The runtime then ingests that data-defined definition (i.e. the sum of all an application’s components) and renders it into a fully functioning application in real time.

Of course, the Enterprise App Cloud doesn’t get rid of code altogether. Just as cloud computing still requires servers, the Enterprise App Cloud Services (runtime) is itself built with code. And the Enterprise App Cloud calls on and activates pieces of that code. 

However—and this is the important part—developers are completely shielded from that code and its machinery. Just as a cloud customer never has to worry if a particular server is working, a developer never has to worry about the code that actually renders the applications they build. That is the job of the Enterprise App Cloud.

Obviously, 100% visual configuration speeds application development. However, there is another powerful implication. Because the Enterprise App Cloud definition is entirely structured, it doesn’t matter what technologies the Enterprise App Cloud runtime calls on and activates. The application never needs to change, even when the technologies around it do (which they definitely will). 

That is to say, Enterprise App Cloud apps are, by definition, future-proof!

To understand the value of these “pure configuration” applications, it is helpful to think about the cloud. A cloud provider can swap out old servers for better, faster ones. The cloud customer gets faster, more reliable service, but they have to make zero changes to the apps they are running.  

In the same way, the Enterprise App Cloud Services (runtime) can keep incorporating the best new technologies that make applications run better and do more—but with zero changes whatsoever to the applications built in the Enterprise App Cloud. 

How the Enterprise App Cloud transcends low-code/no-code

Because the Enterprise App Cloud technology is relatively new, it is often lumped in with low-code/no-code platforms. It is true that both an Enterprise App Cloud  and low-code/no-code offer tools like visual drag-and-drop that speed and simplify software development. However, the Enterprise App Cloud is not just the next iteration of low-code development.  A look under the hood reveals how it is fundamentally different from low-code/no-code. 

Low-code/no-code platforms do not create a structured, data-defined configuration of the application. Rather, they transform each drag-and-drop specification immediately into code, often in a bespoke language that is hard for developers to understand. To compound the problem, low-code/no-code generally automates the creation of only 70-80% of the functionality enterprises require. 

So how do developers fill the gap? By writing code manually. 

The real cost of all the code that low-code/no-code—whether generated automatically or manually—lies in the tech debt it leaves behind. Essentially, you’re back on the same code treadmill that manual coding demands. Why? Because all that code needs to be packaged, deployed, rolled-back, secured, managed, and upgraded in the same old painstaking, manual, and risk-prone ways. 

Granted, some low-code/no-code providers do containerize the code and offer hosting as a new way to manage software. The problem is, containerization offers no real advantage over regular code-based software when low-code/no-code applications are deploying bespoke codebases and runtimes.

Going back to my favorite cloud-hardware analogy, low-code/no-code does the equivalent of automating the procurement of physical servers (code) to be deployed in server closets (codebase). That’s helpful if server closets are the best way to run a company, but we now know better. And that’s why most low-code/no-code is nothing but lipstick on legacy code.

IV. How 100% data-defined development accelerates time-to-market (and that’s just the beginning) 

As we have seen, the Enterprise App Cloud that is powered by 100% data-defined development completely abstracts away all code from the software development process, not just 70-80% of it like most low-code/no-code platforms. As a result, the entire software development process becomes 100% visual and configurable. 

In addition, it turns individual components of an application into a structured, data-defined atomic unit. As a result, these units can then be composed into reusable microservices and other higher-level application functionality. Separating configurations from code means that the Enterprise App Cloud provider can easily and efficiently handle all the mundane tasks that can add up to crushing tech debt over the course of the entire SDLC (a benefit we cover more fully in the next section). 

Not surprisingly, organizations can typically create apps 3X faster—and as much as 10X faster—with the Enterprise App Cloud vs. low-code/no-code. This approach also makes everyone involved in the process of application development more productive. To understand why, consider how the Enterprise App Cloud transforms the way everyone involved—business users, newbie developers, and seasoned engineers—does their job. 

Benefits for business users 

By making development entirely visual (think Visio), business users can: 

• Actively participate in development by following the process visually, rather than handoff requirements to the tech team.

• Build straight-forward applications themselves and add/change functionality, while tech teams can ensure all necessary guardrails are in place.

Benefits for new developers 

People new to development can begin composing complex enterprise-grade applications within weeks, because the Enterprise App Cloud:

• Doesn’t require learning a new coding language.

• Makes building workflows and apps entirely visual, including integrations and data management.

Benefits for seasoned engineers

By eliminating the hard work of manual coding, seasoned developers can focus on high-level functions like:

• Quality control

• Security and governance

• Management of mission-critical legacy systems

V. How the Enterprise App Cloud removes friction from the entire SDLC

While the Enterprise App Cloud speeds and simplifies development, it is the value it brings across the software development life cycle that makes it a truly transformational technology. And again, its power to do so begins with the fact that  applications built in the Enterprise App Cloud are really only configuration files—100% structured data rather than unstructured, language-based code. 

As a result, the Enterprise App Cloud provider can take care of 100% of the underlying code—along with the security, compliance, and upgradeability related to it. And that means organizations can focus precious talent and budget on innovation instead of managing (and paying down) tech debt. 

To understand the power of the Enterprise App Cloud to eliminate tech debt, let’s first consider traditional development methods, including low-code/no-code, in which apps are not configurations calling code but consist of code themselves, whether those lines of code (LOCs) are manually or automatically generated.  

Every codebase you use requires its own runtime—the equivalent of a server-closet in the pre-cloud days. Like server-closets, each codebase requires a separate lock and a security guard to keep hackers away, plus cameras and sensors to monitor activity and an HVAC system to make sure things don’t overheat. 

In other words, each new runtime introduces a whole new set of problems and risks. And yet, enterprises typically run hundreds, even thousands, of codebases—a true security, scalability, and maintenance nightmare. 

To make things even worse, those codebases often include exactly the same set of functionality, and therefore a fresh set of LOCs that need to be managed. When you need to upgrade or security-patch a functionality, you need to do it individually across all those codebases, and then redeploy them one by one. 

None of that is necessary with the Enterprise App Cloud. You have only one runtime that runs on one codebase, providing the cloud-like mega-scale that enterprises need. Each application has its specific configurations, but all run on the same codebase that can be secured, monitored, and maintained at scale. Here are just a few of the benefits:

Speed to insights

Every IT organization must answer a number of critical questions about the apps it runs. How many potential vulnerabilities does it have? Are the roles set up properly? Does it have the optimal architecture? Does it create bottlenecks? What is the distribution of functionality that it uses? 

Because applications built in an Enterprise App Cloud are just configurations that run on a single code base, it is far easier to build a control tower that can answer these questions instantly. That is why these apps typically have 100x fewer bugs and architectural defects than traditional apps.

Reduced TCO 

By decoupling the Enterprise App Cloud from the runtime that executes it, that runtime can be optimized, upgraded, and scaled as new technologies come online. And yet the definition of the application never has to change! As a result, applications can always run on the latest and greatest technologies. 

Equally important, an Enterprise App Cloud powered by 100% data-defined development only requires one runtime across all applications. This enables scalability, reusability, security, and efficiencies that low-code/no-code could never match. Not surprisingly, the total cost of ownership (TCO) of applications is typically 65% lower than traditional apps.

Reducing tech debt across the SDLC

These benefits may sound abstract. To bring them alive, let’s take a look at all the tasks the Enterprise App Cloud takes off your plate across the SDLC. 

Infrastructure planning & management

• No need to purchase or manage servers

• No dependencies to install 

• No DNS to configure or URLs to hook up

• No manual management of scalability or availability

UI/Application development

• No need to need to master HTML/Javascript (or any code)

• No need to connect fields to databases

• No need to manually implement validations

• No need to manually build validation displays

Integrations 

• No need to understand how to make requests or find libraries, codes, etc. 

• No need to create secure store for credentials

• No need to manually build out logic of multiple authentication types

Database management

• No need to set up databases or establish connectivity

• No need to run commands to create or alter tables

• No queries to write

• No time or effort to scale or manage availability

Security

• No manual setup of secure user authentication 

• No manual setup of secure data storage and encryption 

• No manual setup for resiliency against cyber attacks

Deployment 

• One-click deployments and rollbacks

• No broken builds

• No time spent on managing builds

Upgrades

• Only upgrade your business logic

• No code changes when upgrading applications

• No need to upgrade underlying tech as it evolves

VI. Your accelerated path from low-code/no-code to the Enterprise App Cloud

We truly believe the inherent advantages of an Enterprise App Cloud powered by 100% data-defined development are so great that it will become as ubiquitous as cloud computing. However, Unqork currently offers the only solution of its kind. 

And this is not speculative technology or a proof of concept (POC). Many of the world’s leading companies use Unqork for many of their most important software projects, including BlackRock, Marsh, Goldman Sachs, New York City, and more. And they trust Unqork because it is engineered from the ground up to handle the demands of the most complex and highly regulated industries, including financial services, insurance, health care, and the public sector. 

Yes, development with the Enterprise App Cloud is fast. So is the process of integrating the technology into your organization. With no bespoke (or in fact any) languages to learn, new developers and even tech-savvy business users can start building applications in just a few weeks. And as a cloud offering, Unqork requires no changes whatsoever to your current IT stack. Your entire organization can be up and running in no time. 

Want to learn more? Take the guided tour below.