Why WebGenie

Because it should be as easy to Create systems
As it is to Imagine them

Business Agility Case Study

Let's imagine we want a simple system (sample screen at right) to track tasks for multiple projects:

Create a system for Projects and Tasks
Tasks have Estimate Days and Remaining Days, totaled into the project
Ensure Projects Remaining Days total does not exceed its Budget
On insert, Remaining Days is set to Estimate Days

It sounds so simple. And it should be!

Let's explore some technologies designed to help:

Spreadsheets: totals sound like spreadsheets...
Databases: tracking suggests ongoing data entry, maybe we need a database...

Spreadsheets don't fit all problems

Spreadsheets are an attractive approach for handling tabular data with rollups.

The underlying concept of spreadsheets - define expressions that are reevaluated when dependent data changes - was (and is!) a major advance. It would require tons of 4GL code to do what a spreadsheet does naturally.

But spreadsheets don't fit all problems. This simple problem illustrates several issues, described below.

Summing related data across sheets

While spreadsheets are marvelous at computing totals, it's remarkably difficult to sum related data across sheets. In our case, we want each Project to sum its related Tasks.

As you can see at right, it is obscure, at best.

Another example is shown from a different spreadsheet. Good Grief.

Unnatural Display

The display is unnatural - you really want to see a project with (only) its related tasks. See the example at the top of this article.

Scalability

It doesn't really scale... larger volumes of data? Multiple users?

Databases - Right Paradigm, But Too Complex

The problem was that databases are the wrong paradigm. Databases are designed to handle multiple tables (sheets) of related data. This is so common that visual notations have been invented, as shown here,

This diagram illustrates that each Task "points" to a Project - the Tasks project_id matches the Projects' id.

But Database are Complex

But while database structures are a good fit, they are way too complex:

Complex Business Logic: Databases don't have spreadsheet-like expressions to maintain totals.
- As shown here, a simple 5 line spec explodes in 200 lines of code.
Complex database definition: does a foreign key sound, well... foreign?
Complex Forms Creation: screen painters help, but that takes days of fiddling.

With traditional programming, even Low Code, simple business logic explode into complex code.

WebGenie: Simpler Than a Spreadsheet, Full Database Power

The introduction of GenAI changes everything. Suddenly, you can enter our design spec, as a prompt:

Create a system for Projects and Tasks
Tasks have Estimate Days and Remaining Days, totaled into the project
Ensure Projects Remaining Days total does not exceed its Budget
On insert, Remaining Days is set to Estimate Days

And WebGenAI (we call it WebGenie) creates your complete system in 1 minute:

WebGenie creates the complete system in 1 minute:

the Database: no database definition
Forms to review/update data: no screen painting
and the Business Logic to maintain the totals.

WebGenAI Unique Business Logic: the Critical Factor

With WebGenAI, this screenshot shows all that's required to create and run a system.

Observe the following:

Tasks have Estimate Days and Remaining Days, totaled into the project
Ensure Projects Remaining Days total does not exceed its Budget

This is the business logic. With WebGenAI:

It represents 2 spreadsheet-like formulas, stated in simple Natural Language.
It replaces about 100 lines of complex code
It's unique to WebGenAI.

Using traditional approaches, it's nearly half the development effort.

And When You're Ready to Take Off

It often happens that simple systems like these prove valuable, and then require complex extensions to provide even greater value. These often require developers. Original creators expect the developers can just 'start where they left off'...

But this is ofen not the case. Many other products use non-standard databases, or preclude the use of key developer tools for development or deployment.

The result: "sorry, we have to start over". Bringing along all the database complexity described above.

WebGenie Uses Standards

WebGenAI projects are standard Python projects that can be opened in the developers favorite IDE. And they can be deployed as containers - cloud, or on-premise.

No FrankenCode

Developers are often wary of code-generators that produce voluminous Frankencode, that is too hard to maintain or extend. With WebGenAI, the rules translate directly into Python code, and work with your IDE's debugger.

With WebGenAI, you can transform simple projects into Enterprise projects, without starting over.

Summary

Spreadsheets are fantastic tools, but many problems require more power.

If you require totals in 1 sheet based on related rows in another sheet, it's a poor fit for spreadsheets.

GenAI technology now means you can create full systems in about a minute, with just a prompt:

Database: no database definition required
Forms: no screen painting
APIs: web access
Business Logic: not "your code goes here"

That's faster and simpler than a spreadsheet, with all the underlying power of a database.

And when the apps need upgrades, the created projects can easily be extended by developers, using tools they require, without starting over.

Create full system from Natural Language prompt:

Simper: no database definition, no screen painting
Faster: runs in 1 minute
More Powerful: business logic, extend as required with full IDE / container deployment

Page updated

Google Sites

Report abuse