Invented by Sullivan; Brian Joseph, Andrade Garcia; Antonio, Zwiren, JR.; Richard Pat, O’Brian Dellinger; Paul Francis, Loewy; David Kurt, Appian Corporation

Modern software needs to grow and shrink as demand changes. Building software that does this, especially without writing lots of code, is tough. A new patent application introduces a system that lets anyone create and run software processes that automatically adjust to changes. This article breaks down the meaning and importance of this invention into three simple, engaging sections.

Background and Market Context

Let’s start with why this new system matters. Today, businesses and people want their software to do more, but not everyone is a coder. No-code and low-code platforms let people build tools without needing to write much code. These platforms are popular because they make software creation open to more people. But, as these tools become more common, there’s a big problem: most users don’t know how to make their apps handle huge spikes in usage or keep costs low when demand drops. Traditional systems need experts to manage this, and that adds cost and slows down innovation.

Think about a busy online store during Black Friday. The number of shoppers jumps fast, and the store’s software must keep up. Old solutions require someone to manually add more servers or tweak settings. Newer cloud services can add and remove servers, but setting all this up is complex. For no-code users, who might be small business owners or non-technical staff, these details are out of reach.

At the same time, organizations need trust and security. If a system goes down or mixes up data, business stops. So, the market wants a way to let anyone design software, but with the safety, speed, and flexibility that big companies expect. That’s where this patent application comes in.

The invention aims to give no-code and low-code users the same kind of power and reliability that expert developers get. It promises to make software that grows or shrinks automatically, uses resources wisely, protects data, and lets multiple people or groups work safely side by side. In simple terms, it’s about giving everyone the keys to run strong, smart, and safe software—without needing to know how it all works under the hood.

Scientific Rationale and Prior Art

Now, let’s look at the technical challenges and what inventions came before. Computers can run many things at once, but splitting the work and keeping everything in sync is tricky. In the past, systems like Kubernetes, Docker, and big cloud providers (like AWS or Azure) let experts run lots of small “containers” that turn on or off as needed. These systems are flexible, yet they require deep knowledge to set up, and they don’t connect easily to no-code tools.

No-code and low-code platforms, like Zapier, Appian, or Microsoft Power Automate, let users drag and drop steps to build processes. However, these platforms often run each process the same way, no matter how much work there is. They don’t break big processes into small, independent tasks that can run on different computers at once. If many people use the process at the same time, things can slow down or even stop.

Older solutions for scaling software often use “queues” and “workers.” A queue collects jobs, and workers take jobs one at a time. If more jobs pile up, more workers are added. But this needs careful balancing—too few workers and jobs take too long; too many and you waste money. Managing which job goes to which worker, making sure data isn’t lost or overwritten, and keeping everything safe is hard work and usually needs a developer.

Another problem is data sharing. If two parts of a process change the same piece of data, they can get in each other’s way. Programmers use things like “locks” or “transactions” to protect data, but these are invisible to most no-code users. Without protection, data can become wrong or get lost.

Some platforms let users group tasks or run them in parallel, but there’s no simple way for non-experts to control how these groups are managed. Users can’t say, “run this part over here and that part over there, but keep them safe and fast.” If errors happen, it’s hard to track down what went wrong.

This patent application recognizes all these problems. It builds on ideas from cloud computing, distributed systems, and visual programming, but it goes further. It brings real, technical solutions—automatic scaling, safe data management, and smart task assignment—into the hands of regular users. No more juggling servers or guessing about queues. The invention makes these details automatic and safe.

Invention Description and Key Innovations

Let’s break down what the invention actually does and how it changes the game. The core idea is simple: any user can design a software process using building blocks called “process nodes.” Each node does a job, like sending an email, calculating a total, or saving a file. The user builds a process by connecting nodes in a visual way—like drawing a flowchart.

When the user wants to run the process, the system does something special. Instead of running everything in one place, it looks at each node and decides the best way to run it. It can send some nodes to one computer (called an executor) and others to different computers. This means many parts of the process can run at the same time, making things faster and more reliable. If lots of people want to use the process at once, the system adds more executors. If things slow down, it moves nodes around to keep everything working smoothly.

Here’s how the magic happens:

– Object-Based Modeling: Every process is built as a collection of nodes. Each node is an object that represents a task or step. Users connect these objects in a way that makes sense for their workflow.

– Elastic Executors: Executors are like smart workers. The system can create, remove, or move executors based on how much work there is. Executors can run on different machines or even use different hardware. If one executor gets busy, others help out. This keeps costs low and speed high.

– Smart Assignment: The system looks at how nodes depend on each other. If two nodes work on the same data, the system tries to keep them together on the same executor, so they don’t trip over each other. If nodes are independent, they can run in parallel, which makes everything faster.

– Unified Datastore: All executors share access to one or more storage spaces. When a node changes a piece of data, the change is saved safely. If another node needs that data, it gets the latest version. There’s also a local “cache” for quick access, but the system keeps everything in sync to avoid confusion.

– Task Manager: This part acts like a traffic cop. It keeps track of what needs to be done and who should do it. If demand goes up or down, it reassigns tasks to keep things balanced. The task manager uses rules about how busy each executor is and how fast things are running, so no one gets overloaded.

– Load Balancing: The system breaks up big groups of tasks into smaller “sub-groups.” Each sub-group can have its own executor. This means the system can adjust to small or big workloads quickly, without anyone needing to adjust settings.

– Workload Isolation: If a process or node has a problem—like an endless loop or a bug—the system keeps it away from other work. This way, one bad process can’t break everything else.

– Plug-and-Play Components: Each part of the system (like storage, compute, or task management) can be changed or upgraded without breaking the whole thing. This helps the system stay up to date and useful for a long time.

All these innovations come together to give users a powerful, safe, and flexible system. Users don’t have to think about the hard parts—like scaling, data safety, or speed. The system handles it all, automatically. For businesses, this means less downtime, lower costs, and the ability to build and run new tools quickly. For developers, it means they can trust the platform to manage scaling and data, so they can focus on solving problems instead of fighting fires.

In simple terms, this invention lets anyone create smart, elastic software that just works—no matter how big or small the job gets, and no matter who is using it.

Conclusion

This patent application brings together the best ideas from cloud computing, process automation, and no-code design. It solves the biggest problems facing non-technical users: making sure software can grow, shrink, and stay safe without expert help. By breaking processes into objects, using smart executors, balancing loads, and managing data across the system, the invention promises a new age of easy, powerful software creation. No longer do users need to worry about what happens behind the curtain—the system handles all the details. This means more people can build what they need, when they need it, with the trust that their software will keep up. In a world where speed, safety, and flexibility matter more than ever, this invention is a game changer.

Click here https://ppubs.uspto.gov/pubwebapp/ and search 20250217202.