Automation turns your prompt into a microservice: a working application, a database, and a standard JSON:API.  For example, this creates a complete system (see the video, below):

Create a system with customers, orders, items and products.

Include a notes field for orders.

It simply cannot be faster or simpler.

• Working Software in 60 Seconds means Instant Collaboration

  1. 1. • Eliminate weeks to months of complex framework coding, db design, or screen painting.... just to find misunderstandings

• Simplicity empowers Business Users to test their own ideas

• Iterate 15 times... before lunch

• Empower UI Developers with running API, providing logic and security.  Use your favorite tools: conventional framework, AI/Dev, or JSON-aware Low Code.

Backend logic for logic and security can be as much as half the effort.  GenAI-Logic provides declarative logic to address this using spreadsheet-like business rules, in Natural Language or Python.

Logic - Declarative Multi-table Derivations and Constraints

You can express Declarative business logic in Natural Language:

    1. The Customer's balance is less than the credit limit

    2. The Customer's balance is the sum of the Order amount_total where date_shipped is null

    3. The Order's amount_total is the sum of the Item amount

    4. The Item amount is the quantity * unit_price

    5. The Item unit_price is copied from the Product unit_price

Or, you can express them using Python, with IDE services for code completion.  See the example in the next section.  

In addition to declarative logic, you can also add custom logic, leveraging the full power of Python and its libraries.

The 5 rules represent the same logic as 200 lines of Python:  40X more concise.  This represents a meaningful advantage in time to market, transparency, and maintenance.

Security - Authentication, Role-based Row-Level Access Control

You can also declare security:

• Authenticate, using a SQL database, or configure Keycloak for Single Sign-on and login using social accounts such as Google or Facebook.

• RBAC (Role Based Access Control):  declarative row filters for roles, ensuring they see only authorized data.  For example, focus sales on high-value accounts:

Grant( on_entity = models.Customer,

       to_role = Roles.sales,

       filter = lambda : models.Customer.CreditLimit > 300)

The systems created are not throw-away prototypes.  They provide a robust 3-tiered architecture, and can be customized with standard development tools.  

You get the simplicity of AI, the speed of Low Code, and the flexibility of a Framework.  

 Customize and iterate:

• Download the created  project, and customize in your IDE.   

• Use standard Python: e.g. provide Application integration (custom APIs and Kafka messaging) 

• Created projects are model-based, so the code easy to debug and customize:

  1. 1. 1. 1. The API is 1 line per table

           2. The App is a json file (no Java Script, HTML, ...)

           3. The logic is expressed in declarative rules.  For example,   the Natural Language logic above  is translated to (or can be directly entered as) Python:

   # Ensures that a customer's balance is less than their credit limit.

   Rule.constraint(validate=Customer,

               as_condition=lambda row: row.balance <= row.credit_limit,

               error_msg="Customer balance ({row.balance}) exceeds credit limit")

   # Calculates the customer's balance - sum of the unshipped orders' total amounts

   Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total, 

where=lambda row: row.date_shipped is None)

   # Calculates the order's total amount as the sum of its items' amounts.

   Rule.sum(derive=Order.amount_total, as_sum_of=Item.amount)

   # Calculates the item amount as the product of its quantity and unit price.

   Rule.formula(derive=Item.amount, 

as_expression=lambda row: row.quantity * row.unit_price)

   # Copies the unit price of the item from the associated product.

   Rule.copy(derive=Item.unit_price, from_parent=Product.unit_price)

A fast start is great, but delivering value requires systems integration:

• Project can access multiple databases, including Sql/Server, Postgres, MySQL, Oracle, etc.

• Extend the API to provide Custom Endpoints

• Kafka Message Integration, to publish changes, and listen for changes

• Multiple Database Support, so your project can integrate multiple databases

Created projects include scripts to create standard containers, providing

• Scalability

• Flexibility - deploy anywhere

GenAI-Logic Kickstart

GenAI-Logic speed and simplicity means anyone in your team can kickstart a project in under a minute.  Just provide a prompt.

You get running screens, with test data.  Vet your backlog, and collaborate / iterate to get the requirements right, based on working software - with logic and security - not wireframes.  

This runs in 1 minute:

Create a system with customers, orders, items and products.  Include a notes field for orders.

Use LogicBank to enforce use case: Check Credit:

    1. The Customer's balance is less than the credit limit

    2. The Customer's balance is the sum of the Order amount_total where date_shipped is null

    3. The Order's amount_total is the sum of the Item amount

    4. The Item amount is the quantity * unit_price

    5. The Item unit_price is copied from the Product unit_price

When the requirements look solid, transition to development by downloading the project.  It already has a solid base:

• requirements - verified by collaboration using running screens, with logic-driven behavior

• technology - a logic-aware API

Declarative, Standards-based Development

Declare logic and security using declarative rules - 40X more concise than code.  You are still operating at the speed of GenAI, but now with all the power of a framework: standard language (Python), IDE and source code control.  

For example, integrate your system with partners using B2B APIs, or internal systems using Kafka or email.

Custom App Dev is dramatically simplified since you are building on solid foundation of requirements consensus, and an API that has already factored out the logic for re-use.  Use your favorite UI Dev Tools:

• Standard frameworks

• Low Code Products that are JSON:API aware

• AI/Dev tools that provide language-assisted app dev

Standard Deployment

When you are ready to deploy, use the automatically created scripts to create scalable containers.  They deploy anywhere, and are royalty free.

This includes transitioning your test (sqlite) database to other databases such as Postgres, Oracle, MySQL, SqlServer, etc.  If you want to use an existing database, review these database design considerations.

Many organizations have a backlog of business initiatives requiring assessment. They also see promise in AI technology. 

GenAI-Logic enables a safe and efficient program of using AI to vet the initiatives, and delivering them into an Enterprise portfolio:

1. Use GenAI-Logic to create prototypes nearly instantly.

   1. These efforts can expose the organization to AI with little training or effort

   2. Our approach eliminates the risk and uncertainty of AI - created, projects do not suffer from hallucinations

2. Decision makers can access them - live screens and test data, available on the network - to select those to prioritize

3. Selected projects can enter the development phase instantly

   1. Developers will appreciate that they can use standard languages and IDEs

   2. Architects will appreciate they begin with a solid backend - an enterprise-class API providing filtering, sorting, pagination, optimistic locking, and logic reuse / automation

   3. Managers will appreciate the automation-driven cost reductions, the simplicity that enables more of the team to participate, and risk reduction provided by starting with a functional backend

   4. UI Developers will appreciate that they can begin custom app dev immediately, rather than be compressed into the end of the project awaiting backend services

4. Projects are robust and Enterprise-ready, with support for popular DBMSs, multiple database support, and full support for API and Messaging

5. DevOps and Accounting will appreciate the cost-free flexibility to deploy containers anywhere

6. Maintenance Teams will appreciate that the systems are model-based, so much simpler to understand and extend that projects with a very large code base

GenAI -Logic can help Systems Integrators close business, and deliver it.

Close Business with Proposals that include Working Software

While your competitors are pushing documents that act as sleep aids, your proposal can differentiate with running software.  The message is simple and clear:

• We understand what you want

• And we can deliver.  In fact, we've already started.

Increase Margins GenAI Logic Automation

Starting projects with a framework is highly complex: time-consuming, and requires near-rocket-scientist expertise.  This can limit delivery capacity, and increases the risk of failures.

With GenAI Logic:

• Your core framework is automated - an enterprise class API with filtering, sorting, pagination, optimistic locking -- right out of the box

• Use business rules to reduce backend work by 40X

• Developers use their IDE and familiar tools

These cost savings can increase your margins, 

while delivering value that translates to future business.

Delivering Better Results

Logic-enabled projects are far simpler to iterate (logic is automatically ordered and invoked), so future maintenance cycles are far more efficient.

Framework-based API development is time-consuming and complex. Since client App Dev depends on APIs, front-end dev is often blocked. This serialized dev process reduces business agility, and increases pressure on the team.

API Logic server can change that.

1. API Automation means client App Dev can start as soon as you have a database

2. Logic Automation means that

   1. Such logic - a substantial element of the system - is automatically partitioned out of each client into server-based logic. This reduces client coding, and enables the logic to be shared between user interfaces and services.

   2. Logic development can proceed in parallel with client App Dev

Explore this article, or this Tutorial.

API and Logic Automation begins with a database.  But what if it's a new project, and there is no database.

You can certainly use your SQL tools.  But we all know that SQL can be... tiresome.

AI provides a solution:  Schema Automation.  You can use GenAI-Logic to create the system like this:

   Create a system with customers, orders, items and products.

    Include a notes field for orders.

    Enforce the Check Credit requirement (do not generate check constraints):

    1. Customer.balance <= credit_limit

    2. Customer.balance = Sum(Order.amount_total where date_shipped is null)

    3. Order.amount_total = Sum(Item.amount)

    4. Item.amount = quantity * unit_price

    5. Store the Item.unit_price as a copy from Product.unit_price

Here's a tutorial you can to explore this,  or see this article.

Api Logic Server creates an executable multi-table Admin App.  Optionally add Logic and Security.

Use this app for:

• Admin Data Management: for lookup tables, table-driven meta data (e.g., General Ledger allocation definitions), etc.  These often fall off the schedule, requiring the use of SQL tools that are hard to use, and don't provide logic or security.

• Data Correction: the realities of database use can result in invalid data (data loading, poor quality feeds).  These often require manual effort with SQL tools to find and correct such data.  This requires manual data validation, which may be inconsistent.  GenAI-Logic enables you to provide a professional interface, backed by logic and security.