How Lumetis works
You describe an app and Lumetis builds it. Then you keep changing it in plain English, and every change is checked before it replaces the version you are using.
Four steps
The first three take minutes. The fourth is the one you come back for.
-
Step 1
Describe it
Write what your app should do, in one sentence or a full page.
One sentence is enough to start. The example here is the one the product itself suggests.
-
Step 2
Answer a few questions
When a choice matters, Lumetis asks before it builds.
You answer in the same chat, then press Generate App.
-
v1 live
Step 3
Open your app
Lumetis builds the backend, the database and the interface, and shows you the decisions it made.
The build keeps running if you close or refresh the page. When it is done you can open the app, preview it and view the code.
-
v2 live
Step 4
Keep improving it
Ask for changes in plain English. Lumetis checks each one before switching to it, and keeps every version.
One change runs at a time per app, in the background, so you can leave and come back.
The panels beside the steps are recreations of the product, with example data.
What happens when you ask for a change
Lumetis updates the app, checks it, and switches to the new version only if the check passes. Otherwise the current version stays live and you get a message explaining what happened.
-
Your request
Add an expected close date to each deal and show it on the pipeline cards.
-
Understanding your request
It knows your app. Lumetis keeps a model of your whole application: its data, pages, relationships and rules. Each request is handled with everything else in mind.
-
Preparing the change
The request changes that model first.
-
Building the update
The code is regenerated from the model, so the change stays coherent with the rest of the app.
-
Validating the update
Checked before it goes live. Lumetis applies your change, tests the result, and only switches over when it passes.
Nothing breaks silently. If a change fails, the version you have keeps running and you get a clear explanation.
-
Activating the update
The new version becomes the one your app runs on.
-
Version 5 is live
Every version kept. History shows each accepted version and which one is live.
Version 4 stays in History.
The steps are the ones the product shows while a change runs. The app and its data are an example.
What you get
- A backend
- An API with routes, business rules and validation, written in Python with FastAPI.
- A database
- Tables and relationships designed for what you described. SQLite by default.
- An interface
- Pages, forms and navigation in React, wired to the app's own API.
- The history of versions
- Every accepted version is listed, and the one in use is marked.
- Technical documentation
- For every accepted version, exported as a ZIP a developer or an auditor can read.
What it's built on
A generated app is standard code in a standard stack. It also comes with a README, requirements and package files.
Interface
React,Vite,Tailwind
The pages, forms and navigation people use, wired to the app's own API.
Backend
Python,FastAPI,SQLAlchemy,Pydantic
An API with routes, business rules and validation.
Database
SQLite by default
Tables and relationships designed for what you described.
What it doesn't do yet
Three things people ask for that are not in the beta.
Publish an app for other people
Today an app can only be opened from its owner's account. Publishing apps on Lumetis is on the way.
Export the code
GitHub export is planned. You can already view the code and download the technical documentation for every version.
Work on an app it didn't build
Understanding software you already have is what we're working on next.
Lumetis is in private beta.
Request access and we'll send you an invite.
Free while in beta, with your own AI key.