What Modern No Code Platforms Inherited from Lotus Notes

It’s been more than 15 years since I co-developed my first NoCode platform. A lot has changed since then — back in those days, the term “nocode” didn’t even exist. Software was delivered on CDs and DVDs, conversations revolved around compilers and memory leaks, and “cloud” was still a taboo term in many organizations, often dismissed as insecure. We were simply trying to make it easier for end users to create their own solutions using our software. The features were buggy, the learning curve steep, and the first people we trained were usually the sales team — which didn’t always go smoothly.

Fast forward to today, and the explosion of NoCode platforms across industries is hard to ignore. A vibrant community has formed around them, venture capital is pouring in, and everyone from solo entrepreneurs to large enterprises now recognizes that NoCode is shaping the future of software development.

In this article, we uncover the foundational ideas behind modern no-code platforms — not by looking at the latest tech stacks, but by tracing their conceptual lineage back to Lotus Notes and its creator Ray Ozzie. While today’s tools are flashier and cloud-native, many of their most powerful features were already imagined decades ago. We distill these enduring principles and show how they continue to shape platforms like Unqork, ServiceNow, and ACENji.We’ll also look at why small businesses in particular are embracing this movement. If you’re interested in more context, check out our previous deep dives: What Is a No-Code Platform? Five Key Parts Explained and Improved Application Development with NoCode Platform.

Creative people make creative software, and the nocode evolution started with Ray Ozzie, the co-founder and creator of Lotus Notes. 

For full access to his biography, visit his wikipedia page 

He never actually used the keyword “nocode” but many of his ideas laid the fondaiton for what we now call nocode development.

Here are most important principles and key concepts I put together, derived from his work and public commentary. 

Disclaimer: The statements below are paraphrased principles inferred from Ray Ozzie’s vision and work. They are NOT direct quotations.

• Empowering Business Users 

“Let end users build their own solutions.”

• Ozzie believed non-developers should be able to create tools that solve their business needs without waiting on IT.
• Lotus Notes allowed users to build custom forms, workflows, and applications using a visual interface — no traditional programming needed.
• This is a direct precursor to modern nocode democratization.

• Templates and Reusable Design

“If one team solves a problem, others should reuse it.”

• Notes supported application templates and shared libraries, encouraging modular, reusable components — just like today’s nocode block builders.
• Reuse reduced training time and boosted adoption.

• Declarative Over Procedural

“Define what the application should do, not how.”

• Lotus Notes used a declarative configuration model for forms, fields, rules, and agents.
• This let users focus on business logic, not procedural programming — a defining principle of modern nocode platforms.

• Built-In Workflows and Automation

“Software should help you act, not just store data.”

• Notes let users automate processes, send notifications, and define workflow rules visually.
• This was decades before tools like Zapier or n8n.
• It’s the early version of workflow automation in nocode.

• Integrated Collaboration

“Communication and apps should live in one system.”

• Ozzie wanted users to collaborate directly inside their apps — sharing documents, comments, tasks.
• Lotus Notes included email, document databases, and application logic in one platform.
• This mirrors the collaborative and embedded nature of many modern nocode tools like Notion or Airtable.

• Data + Logic + UI in One Platform

“Build full-stack business apps — no back-end needed.”

• Notes combined a data store, logic engine, and UI builder in a single package.
• This is a direct match for how modern nocode platforms are structured — from Bubble to Retool to ACENji.

As you see , even back then, some of the most important concepts for great nocode platform were defined. Ok, if that is the case, then it i sall solved by now , right. Well not so fast. Modern day applications are also very creative but they all saffer form crowd mentality and follow “wise” architectural trends, just few years down the road to be discovered that where wer enot so wised.
Take for example the Unqork nocode platfom. From their patent US11204690B1 we can identify the core technology and concepts that built the platform. Lets take a closer look:

1. Graphical User Interface (GUI)–Driven Development

• Users can drag-and-drop components into a development window to create electronic forms.
• Each component (e.g., input field, decision logic, workflow) includes a customization interface for parameters, background processes, and business logic.

2. Advanced Event and Workflow Processing

• Decision components: Trigger real-time actions based on form inputs (e.g., validation, field visibility, conditional logic).
• Workflow components: Enable background data processing using node-based diagrams (input → processing → output nodes).
• Includes filtering, mapping, natural language processing (NLP), and other advanced data transformations.

3. Declarative Application Packaging

• Combines UI, logic, and data layers into a single integrated software bundle.
• Deployable in cloud environments or through third-party systems.

4. Architecture:: Version Control System:

• Tracks changes across versions of forms and components.
• Allows visual comparisons and rollbacks via an in-app timeline.
• Supports collaborative editing and version labeling.

5. Architecture:: Machine Learning Module:

• Analyzes aggregated form data.
• Auto-suggests form modifications, detects validation issues, and enriches data (e.g., converting paper forms to digital).

6. Architecture::Integration Layer:

• Automatically generates an API for each form.
• Enables real-time data access and execution outside the GUI.

7. Architecture::Deployment Engine:

• Publishes forms as live applications directly from the design environment.
• Supports both public and private deployment scenarios.

Unqork uses at least 7 of the 8 “Nocode” core principles Ray Ozzie  had declared at his time.

Lets take another random nocode patent: US20230146421A1 – Low-Code and No-Code Customization User Interface Components

This one belonds to Service Now INC.We can identify the core technology and concepts that built the platform. Lets take a closer look:

• Platform UI Builder (Design-Time Environment)

• Users select UI components from a predefined set.
• They configure data bindings and transformations using either:
  • Low-code expressions (e.g., IF(…), CONCAT(…)), or
  • No-code visual menus with dropdowns and value fields.
• Inputs are compiled into structured metadata (e.g., JSON/XML), not code.

• Metadata-Driven Runtime (Execution-Time Engine)

• A runtime engine interprets the metadata and dynamically:
  • Loads data from sources (database, API, state)
  • Applies transformations (arithmetic, string, logic)
  • Renders custom UI components using bindings and logic

• Separation of Design-Time and Runtime

• Design-time: Users define logic visually or semi-visually via the builder.
• Runtime: The system executes the UI using the metadata definitions, without compiling or deploying traditional code.

And finally, lets look ACENji’s patent US20240069872A1No-code software development platform. 

Core Technologies and Architecture of ACENji

1. Graphical User Interface (GUI)–Driven Development

• Users create applications by dragging tiles representing functional units (forms, cards) into a design canvas.
• Each unit includes declarative parameters, conditional logic, styling, and workflows.
• Visual UI builder simulates real app behavior without writing code.

2. Advanced Event and Workflow Processing

• Supports nested conditional logic: if, then, else, and do-while.
• Events (e.g., screen transitions, form submissions) are defined declaratively.
• Workflows span multiple screens and cards with multi-directional logic and branching.
• Includes workflow simulation and testing inside the editor.

3. Declarative Application Packaging

• Combines UI layout, user logic, workflow behavior, and data operations into JSON-based ACENji language.
• One declarative file defines a complete app, usable across mobile, web, or embedded devices.
• Seamless runtime environment interprets and executes the packaged application in real-time.

4. Architecture:: Conditional Logic Engine

• Declarative condition blocks define flow control and visibility logic.
• Allows deeply nested logic and dynamic routing of users across pages/screens.
• Visual test simulator embedded in the builder to verify conditional outcomes instantly.

5. Architecture:: Plugin & Integration Layer

• Plugin interface allows connections to third-party CRMs, ERPs, APIs, blockchains.
• Plugins use declarative logic to define pre-conditions, post-conditions, and execution behavior.
• Security validated via blockchain hashing for plugin artifact integrity.

6. Architecture:: Deployment Engine

• One-click deployment to mobile (iOS/Android), web, embedded devices.
• Real-time API-based deployment—no rebuild or recompile required.
• Supports live preview and instant publishing from design interface.

7. Architecture:: Machine Learning & Schema Inference

• Optional ML layer helps auto-detect headers, define data schemas, and infer user intent.
• Built-in algorithms: decision trees, neural nets, Bayesian models.
• Enhances user experience by simplifying data mapping and normalization.

8. Architecture:: Access Control & Hierarchy

• Admin interface supports geolocation-based and role-based access control.
• Multiple user tiers (super admin, admin, contributor).
• Built-in simulation of user access without passwords (for testing and provisioning).

ACENji utilizes all 8 of the “NoCode” core principles originally identified by Ray Ozzie, including declarative logic, drag-and-drop design, deployment automation, and layered integration—solidifying its claim as a next-generation, enterprise-ready no-code super app platform.

As we see most and not suprizenly, today’s nocode platforms are with easy covering the core principles of Ray Ozzie and that defines how a nocode platforms look from the angle of 1980’s.

But like everything else, additional progress is always made.
There are at leastthree other principle that need to be added in this age:
– “ users and/or  machines can both equally create endless nocode apps”

• “Users and/or machines can utilize blockchain technology”

Acenji actually covers those two in its own patent. For more on how to use blockchain with nocode platform, , check this article 

No-Code and Blockchain: A Powerful Tech Evolution Ahead

And the last one is “A Turing-complete Super App builder can only be achieved through a truly 100% no-code platform—where business users can express complete application logic, data flow, and user experience without writing a single line of code.”

So the idea is that Turing completeness doesn’t require writing code—it requires the ability to express full logic, and a well-designed no-code platform can do this, but only if it’s 100% no-code and fully expressive.

And for those who still wonder about super apps, it is worth the time to check our article what is a super app?

Thanks for reading

By Ivan Assenov