Skip to content


💡 TL;DR: Instant Creation, Rules, Standard Tooling.   Open Source.

Eliminate long dev cycles that delay Agile Collaboration and custom app dev with Working Software, Now.

API Logic Server is the fastest and simplest way to create modern, scalable API-based database systems:

  1. Create: ApiLogicServer create builds an executable project from your database, instantly:

    • Multi-page web app - enable agile collaboration

    • Self-serve API - unblock custom App Dev

  2. Customize: using Python, your IDE and standard libraries such as Flask and SQLAlchemy:

    • Declare rules that are 40X more concise than code -- unique to API Logic Server    🏆

    • Extend with standard Python

    • Iterate from revised database designs, preserving customizations

  3. Deploy: automated scripts create standard containers for deployment

Check out the new AI-Driven Tutorial -- article here, or watch the video. Also, try the Basic Demo.


Click to see Created Admin App, Project, Architecture


Created Admin App

The Admin App is shown below:

API Logic Server Intro


Customize in IDE

VSCode and PyCharm users can customize and run/debug within their IDE with these steps. Created projects include Launch and Docker configurations.

Customize in your IDE

Rebuild services are provided to accommodate changes to database structure or ORM classes.


Standard, Scalable Modern Architecture

  • A modern 3-tiered architecture, accessed by APIs
  • Logic is automatically reused, factored out of web apps and custom services
  • Containerized for scalable cloud deployment - the project includes a dockerfile to containerize it to DockerHub.

API Logic Server Intro


Check it out

Instant Evaluation - no install

Codespaces unavailable - please use Express Install.

Run in the cloud: VSCode via your Browser, courtesy Codespaces. Use your existing GitHub account (no signup is required), and:

  1. Click here to open the Create Codespace page.

  2. Configure as desired, and click Create codespace.

This process takes about a minute. Wait until you see the port created.

We think you'll find Codespaces pretty amazing - check it out!


Self Demo

You can build a sample app from a simple pre-installed database to see the key features:

  1. To install, click here

  2. To demo the key features, click here

The navigation menu on the left contains the Tutorial and other samples. These all use pre-installed databases.


Instant Cloud Deployment

Follow this procedure to

  1. Create a project from a sample dockerized database

  2. Containerize your project

  3. Deploy to Azure

Once you are installed, the entire process takes well under an hour. You will need an Azure account for cloud deployment (but the prior steps are useful to run).


In a Nutshell

Here is a quick screen-shot demo of the basic process:

Create a Flask/SQLAlchemy project from your database:

Create Project from database, using API Logic Server CLI
ApiLogicServer create --db_url=sqlite:///sample_db.sqlite --project_name=ApiLogicProject

That command creates a standard project you can open and execute in your IDE. Here's the Admin App, ready for business user collaboration:

Admin App

Expore API, Using Automatically Created Swagger - Custom Add Dev Ready


The Admin App provides a link to the Swagger:

Admin App

When you're ready, click 2. Flexible Customization, above.

Customize and debug with standard dev tools. Use your IDE (e.g. VSCode, PyCharm), Python, and Flask/SQLAlchemy to create new services.

Customize API

When you're ready, click 3. Declarative Logic, above.

Declare multi-table constraint/derivation logic, using Python and your IDE. The 5 spreadsheet-like rules below are declarative, representing the same logic as 200 lines of procedural code (40X more concise):

Declarative Logic


  1. You can extend rules with Python, as explained in the Eval
  2. Similar declarative facilities provide row level security, based on a users roles


When you're ready, click 4. Deployment, above.

Projects are container-ready. The system provides configuration and scripts to containerize your project:

Create Image

The container is ready to deploy, on-premise or in the cloud (eg, Azure, AWS, etc):

  • A modern 3-tiered architecture, accessed by APIs
  • Logic is automatically reused, factored out of web apps and custom services
  • Scale using standard toooling such as Kubernetes

API Logic Server Intro


Video: Create, Run, Customize

API Logic Server is an open source Python project, consisting of a CLI and set of runtimes (SAFRS API, Flask, SQLAlchemy ORM, business logic engine) for project execution.

It runs as a standard pip install, or under Docker. For more on API Logic Server Architecture, see here.

Click the image below for a video tutorial, showing complete project creation, execution, customization and debugging (instructions here). Or, see it using AI: click here.

Delivering the Agile Vision



Why It Matters:

Increased Agility and Quality, Reduced Risk

Agile wisely advises getting Working Software as fast as possible, to facilitate Business User Collaboration and Iteration. This reduces requirements risk - substantial effort wasted in misunderstood requirements.


  1. Instant Collaboration: with automated creation of an API and an Admin App, collaboration and UI dev can begin on Day 1.

    • Tradtionally, API and UI Dev is required before Collaboration. This might be weeks or months.
  2. Spreadsheet-like Rules, Self-Serve APIs: rules are 40X more concise, and automatically ordered and reused. Also, APIs are self-serve -- UI developers can use Swagger to formulate requests for filtering, sorting, and multi-table data content.

    • Tradtionally, Logic Development is by code. Manual approaches can miss Use Cases, or be coded in UI controllers instead of the server.
    • Tradtionally, Custom APIs are required for each client app. This can block UI deveopment.
  3. Self-Serve APIs: ongoing API needs can be met by consumers, such as new application integration.

    • Tradtionally, API Consumers may require new custom APIs, which may result in bottlenecks for server developers.

In addition to time, risk is also reduced:

  1. Early Collaboration: reduces requirements risk
  2. API Automation: reduces technical risk (e.g., pagination, optimistic locking, self-serve design).

Finally, automation drives quality automatic re-use and ordering eliminates an entire class of error.


Simpler, Modern Architecture

API Logic Server not only increases agility, it can make web app development simpler, and ensure the architectural result:

  • Automation makes it simpler: this reduces the risk of architectural errors, e.g., no logic reuse between Apps / Services, APIs without pagination, etc.

  • Automation guarantees a modern software architecture: container-ready, API-based, with shared logic between UIs and APIs (no more logic in UI controllers), in a predictable structure for maintenance.


Flexibility of a Framework, Faster than Low Code

Current approaches for building database systems have shortcomings:

  • Frameworks: Frameworks like Flask or Django enable you to build a single endpoint or Hello World page, but
    • Require weeks or more for a multi-endpoint API and multi-page application
  • Low Code Tools: are great for building custom UIs, but
    • Slow Admin app creation, requiring layout for each screen
    • Propietary IDEs don't preserve value of traditional IDEs like VSCode, PyCharm, etc
    • No automation for backend business logic (it's nearly half the effort)

In contrast, API Logic Server provides:

  • Flexibility of a framework: use your IDE's code editor and debugger to customize the created project, with full access to underlying Flask and SQLAlchemy services

  • Faster than low code for admin apps: you get a full API and Admin app instantly, no screen painting required


Use Cases

There are a variety of ways for getting value from API Logic Server:

  • Create and Customize database web apps - the core target of the project

  • Admin App for your database - the Admin App is a create way to navigate through your database, particularly to explore data relationships

  • Agile Integrations replace cumbersome and inefficent ETL approaches with Agile Integrations

  • Data Repair - using the Admin App with logic to ensure integrity, repair data for which you may not have had time to create custom apps

  • Project Creation - even if you do not intend to use the API, Admin App or logic, you can use API Logic Server to create projects you then edit by hand. Created projects will include the SQLAlchemy Data Models, and project structure

  • Learning - explore the Learning Center to learn about key concepts of Flask and SQLAlchemy


Feature Summary

Feature Providing Why it Matters
Instant 1. Admin App Instant multi-page, multi-table app Business Users engaged early

Back-office Admin
2. JSON:API and Swagger Endpoint for each table, with...
Filtering, pagination, related data
Custom UI Dev
App Integration
3. Data Model Class Creation Classes for Python-friendly ORM Custom Data Access
Used by API
Customizable 4. Customizable Project Custom Endpoints, Logic
Use Python and your IDE
Customize and run

Re-creation not required
Unique Logic 5. Spreadsheet-like Business Rules   🏆 40X more concise -
compare legacy code
Unique backend automation
... nearly half the system
Customizable with Python Familiar Event Model Eg., Send messages, email
Testing 6. Behave Test Framework Test Suite Automation

Behave Logic Report

Drive Automation with Agile
Optimize Automation to get it fast

Get it Right with Agile Collaboration


Getting Started - Install, Tutorial

API Logic Server is designed to make it easy to get started:

  • Install and run Tutorial - install, and explore the tutorial. The tutorial creates 2 versions of the sample database

    • without customizations - so you to see exactly what is automated from the ApiLogicServer create command
    • with customizations - so you can see how to customize
  • Installed Sample Databases - Here are some installed sample databases you can use with simplified abbreviations for db_url.

  • Dockerized Test Databases - Then, you might like to try out some of our dockerized test databases.

  • Your Database - Finally, try your own database.


In addition to this app dev oriented tutorial, you can also explore:

  • Deployment: the Deployment Tutorial illustrates various ways to containerize and deploy your applications

  • Using AI: the AI-Driven Automation Tutorial shows how you can use ChatGPT to create new databases from english descriptions, to bootstrap a very rapid create / collaborate / iterate Agile cycle.


Project Information

Making Contributions

This is an open source project. We are open to suggestions for enhancements. Some of our ideas include:

Component Provides Consider Adding
1. JSON:API and Swagger API Execution Kubernetes - extend containerization
2. Transactional Logic Rule Enforcement New rule types
3. SAFRS React Admin Admin UI Enhancements Maps, trees, ...
4. This project API Logic Project Creation Support for features described above

To get started, please see the Architecture.

Preview Version

This pre-release includes:

You can try it at (you may need to use python3):

python -m pip install --index-url --extra-index-url ApiLogicServer==10.0.0

Or use (not available currently):

docker run -it --name api_logic_server --rm -p 5656:5656 -p 5002:5002 -v ~/dev/servers:/localhost apilogicserver/api_logic_server_x

Or, you can use the beta version on codespaces.



We have tested several databases - see status here..

We track issues in git (formerly here).

We communicate via slack.



Many thanks to:

  • Thomas Pollet, for SAFRS, SAFRS-react-admin, and invaluable design partnership
  • Tyler Band, for major contributions on security, testing, features and much more
  • Nitheish Munusamy, for contributions to Safrs React Admin
  • Marelab, for react-admin
  • Armin Ronacher, for Flask
  • Mike Bayer, for SQLAlchemy
  • Alex Grönholm, for Sqlacodegen
  • Meera Datey, for React Admin prototyping
  • Denny McKinney, for Tutorial review
  • Achim Götz, for design collaboration and testing
  • Max Tardiveau, for testing and help with Docker
  • Michael Holleran, for design collaboration and testing
  • Nishanth Shyamsundar, for review and testing
  • Thomas Peters, for review and testing
  • Gloria Huber and Denny McKinney, for doc review



There are a few articles that provide some orientation to API Logic Server: