The next generation of rapid application development.

Idea to production faster than the web has ever seen. No build. No pipeline. No cage.

Your code runs the instant you write it, straight from the database. While their pipeline is still deploying, you’re already live.

Request Access Watch the 2-min Walkthrough →

Their pipeline 11:42

Checkout0:09
Install dependencies2:14
Lint and unit tests3:41
Build bundle2:52
Build container image2:46
Push to registryqueued
Deploy to clusterqueued
Health checksqueued

Frames Studio Live

⌘S contacts_manager_v1 saved — running in production

No build. No pipeline.
This space is empty on purpose.

A typical enterprise pipeline takes 18 minutes. We don’t have one.

No build step. Ever.

Code lives in the database and executes at runtime. Nothing to compile, nothing to ship. Every iteration skips the step everyone else pays for, every time.

RAD without the cage.

Real Python, real HTML, real JavaScript, any CDN, any library, your own code. All the speed of rapid application development, none of the walls that killed the last generation of it.

Your code, portable, always.

Export everything at any time. Stand it up on your own Flask instance and walk away. We host it because it’s cheaper and easier than running it yourself — not because you’re stuck.

Today, Frames Studio is a web application platform for form-based, API-connected business applications — the low-code sweet spot, written in real code. Python microservices on the same runtime are next on the roadmap.

Read this before you pattern-match

Not a site builder. Not an internal-tool wizard. Not AI-generated React.

A new development platform gets sorted into a familiar bucket in about four seconds. Frames Studio does not belong in any of the three it gets thrown into most often — and the reason it does not is the entire argument.

Not an AI code generator

Those tools write you a codebase and hand over the keys. You still own the repo, the dependency tree, the build config, the pipeline, and every line you did not write. Frames Studio hands you no repo, because there is nothing to compile. AI writes straight into a runtime that is already executing.

Not a low-code builder

Drag-and-drop platforms trade capability for a fast start. You move quickly until you reach the edge of what the component library permits, then you file a feature request or rewrite it outside the tool. Here you write real HTML, real CSS, real JavaScript, real Python. There is no ceiling to climb out of, because there was never a box.

Not a faster pipeline

The industry spent fifteen years shortening the build: better bundlers, warmer caches, parallel CI. That work made the pipeline quicker. Frames Studio removes the pipeline. An edit is a row in a table, live on the very next request.

What it is instead

We started at the dirt

Everything Frames Studio gets compared to begins with the stack already standing. Those tools take the toolchain as a fact of life and compete on what sits above it — a better editor, a faster deploy, a component library, a model that writes the files for you. We went the other direction. Down past the framework, past the build system, down to the moment a request arrives. Then we built back up from there.

So there is no toolchain. Not a shorter one, not a managed one. No package manager, no bundler, no transpiler, no build artifact, no image to push, no registry, no pipeline, no release. None of that was optimized away. It was never introduced.

What stands in its place is smaller than what it replaced. Application code is rows in a database, addressed by codename, resolved and dispatched through a single endpoint at request time. Every other property falls out of that one decision: complete version history on every save, because writing is an insert and never an overwrite. Per-tenant overrides that fall back to a platform default. A production site that is also the development site.

AI has a real job here, and it is not the headline. It writes components into a runtime that worked before any model was ever aimed at it. Take the AI away and the platform still stands. That is the difference between a foundation and a trinket.

Judge it on the runtime, not the category.

See it running

A working diagnosis

What are you tired of?

Twelve specific dysfunctions of the modern software development stack. For each one, the architectural principle in Frames Studio that removes it. Here are four to start with.

Tired of watching CI/CD churn for eight minutes to change a button label.

The fix Deployment is an INSERT.

Tired of code living in files while data lives in tables — and the ORM between them being where every second bug is.

The fix Code and data belong in the same substrate.

Tired of framework upgrades that break your application twice a year.

The fix The runtime is the framework. And it doesn’t rev.

Tired of onboarding a new developer taking two days because the local dev environment is its own product.

The fix The interface belongs in the browser.

The Runtime

Your code is rows in a table.
That’s not a metaphor.

Everything an application is made of — every backend function, every UI component, every window definition, every table schema — lives as a text row in one table called code_repository. There is no compile step. There is no build. The row is the running code.

Every row your app runs on. Right here, in front of you.

This is the actual DB Explorer that ships inside every Frames Studio tenant. Same admin toolbar. Same table list. Same grid. Click Refresh and the rows re-fetch — because that’s all a query is.

▢ DB Explorer

Platform Admin (full access)

▢t_00000_contacts_v14r
▢t_00000_holdings_v35r
▢t_00000_inventory_ledge…0r
▢t_00000_inventory_ledge…7r
▢t_00000_inventory_ledge…6r
▢t_00000_portfolio_allocat…1r
▢t_00000_portfolio_allocat…6r
▢t_00000_portfolio_works…1r
▢t_00000_PortfolioModel…61r
▢tenant_00000_activity_log1r
▢tenant_00000_contact_s…1r
▢tenant_00000_data43r
▢tenant_00000_investmen…0r
▢tenant_00000_investors0r
▢tenant_00000_orders0r
▢tenant_00000_pii1r
▢tenant_00000_portfolios0r
▢tenant_00000_stocks3r

Data Schema Query tenant_00000_data

43 rows total

id tenantid type keyval data_json createdat Actions

▢ Launch 2 2 admin@frames-studio.com 06:41:13 AM

This is the same explorer the platform ships to every tenant. Newest row per (codename, codetype, tenantid) wins. Editing is an INSERT. Version history is automatic. Rollback is a WHERE id =.

Tenants get as many tables as they need.

A tenant defines a table by writing a schemacode row. The runtime materializes it on first access. There is no admin. No migration ticket. No DBA queue.

tenant · acme_ltd

acme_ltd_invoices
acme_ltd_customers
acme_ltd_line_items
acme_ltd_audit_log
+ 14 more

tenant · orrum_health

orrum_health_patients
orrum_health_visits
orrum_health_billing
orrum_health_referrals
+ 41 more

tenant · retiree_wealth

retiree_wealth_accounts
retiree_wealth_holdings
retiree_wealth_advisors
retiree_wealth_documents
+ 22 more

The tables you see here don’t exist until a tenant writes them. The {TABLE:invoices} macro is prefixed with the tenant ID at query time, so every tenant lives in its own logical database inside one physical one. Adding a table is one row in code_repository — not a schema migration, not an ops ticket, not a deployment.

Never a compile. Never a build. Never a deploy.

When a request comes in, the runtime SELECTs the row and executes its text directly. The moment you save, the next request runs the new code.

You save a row

INSERT INTO code_repository
(codename, codetype, tenantid, codetext)
VALUES ('Invoices', 'pythoncode',
        'acme_ltd', 'class Invoices: …');

Next request looks it up

SELECT TOP 1 codetext
FROM code_repository
WHERE codename = 'Invoices'
  AND codetype = 'pythoncode'
  AND tenantid = 'acme_ltd'
ORDER BY createdat DESC;

Runtime executes the text

# Python:
exec(codetext, namespace)
cls = namespace['Invoices']
cls().execute(conn, req)

// JS component:
globalEval(scriptText);

TIME FROM SAVE TO LIVE

One database round-trip.

No npm install. No docker build. No CI queue. No blue-green cutover. No cache invalidation. The next request through the door is running your new code.

Ship when you’re ready. Not when the pipeline allows.

This is the mechanic every claim on this page rests on. If you want the deeper walk through the dispatcher, the tenant precedence rule, and the auth model, the platform page has it.

See the platform architecture →

The Thesis — in 42 seconds

Replit moved the toolchain to the cloud.
We removed it.

Recorded this morning · 18 minutes · Unedited

A real session — including
the part that broke.

Most platform demos show the happy path. This one does not. It opens with a schema change going out to production, runs into a genuine deployment error, and works through finding and fixing it from inside the browser. Then it goes on to generate a working contact form end to end, with no compile step and without opening a second tool.

loom.com / building-frames-studio-ai-tools-and-sql

A schema change goes to production

Deploy Manager previews the DDL and asks for approval before anything touches the production database.
It fails on a duplicated schema prefix

A real error, left in. The generated statement carried the schema name twice, and production refused it.
The fix happens in the same window

Claude and the in-browser SQL runner locate the offending statement, read it straight out of the database, and correct it. No local checkout, no redeploy cycle.
Frame Architect and Data Architect

Model definitions and their relationships live in SQL Server as indexed columns alongside JSON, read back with OPENJSON.
A component gets generated whole

The AI Component Builder writes the HTML, the Python, and the frame configuration together, because all three are rows addressed by the same codename.
A contact form goes live reading real data

It pulls from the connected table on the next request. Nothing compiled, nothing bundled, no tab ever left open behind it.

Deep dive · 14 minutes

Using the Architect

The session above passes through the Architect on its way to somewhere else. This one stays there. It is the tool where a model gets defined once — its fields, its relationships, the shape of the thing — and where that definition is stored as data in SQL Server rather than scattered across migration files, model classes, and form markup that have to be kept in agreement by hand.

loom.com / frames-studio-using-the-architect

What one definition turns into

A single codename addresses up to four rows. Define the model, and these are the artifacts that carry it — each one a row, each one editable on its own.

schemacode The DDL. Tables and indexes, written with macros so the same definition lands correctly per tenant.
pythoncode The backend. The class or function that reads and writes the model, dispatched by name at request time.
componentcode The interface. HTML, CSS, and JavaScript for the screens that operate on the model.
framecode The window. Title, dimensions, and icon — how the thing presents itself on the desktop.

Nothing here is generated once and then owned by you forever. Change the definition and the pieces are regenerated; change a piece and it stays changed, because it is just a row.

A Different Paradigm

Websites Are for Reading.
Desktops Are for Working.

The Informational Web

Marketing pages. Documentation. Blogs. Content that people read, browse, and navigate.

Scroll-based. Link-driven. Designed to inform.

This page you're reading right now is an informational website. It should be.

Productive Software

The tools people work in every day. Code editors. Project managers. Design tools. The applications where work actually gets done.

Window-based. Task-driven. Designed for productivity.

Frames Studio chose the interface paradigm that 4 billion computer users already understand.

The objection we hear most is "it looks too different from a website." That's the point. It's not a website. It's a workspace. And it uses the most familiar interface in computing — the one you've been using since you first touched a computer.

How We Compare

Everyone Else Moved
the Toolchain. We Removed It.

Cloud IDEs and AI assistants made the old stack faster, smaller, or more portable. Frames Studio made it unnecessary.

Market Map

Where Everyone Sits

Cloud IDEs sit on the right (heavy toolchain). AI code-gen tools sit on the left (lighter toolchain, but still emit code). Frames Studio is the only point where AI emits frames, not files — with no toolchain to maintain.

Feature Matrix

Side by Side

	Replit	Codespaces	Cursor	Frames Studio
Toolchain	Cloud-hosted	Cloud VM	Local + AI	None
AI output	Code files	Code files	Code files	Frames (executable intent)
Versioning	Git on files	Git on files	Git on files	Git on frames
Cold-start	Container boot	VM boot	Instant (local)	Instant
Multi-tenant	One workspace / user	One VM / user	Local only	Tenant-aware by design
Onboarding	Account + setup	GitHub + container	Install + license	Open a browser

Each row reflects an architectural decision, not a marketing claim. Frames Studio is the only column where the answer is structural — not just faster, but different.

Replit moved the toolchain to the cloud.

We removed it.

Cursor generates code that runs on your toolchain.

We generate frames that need no toolchain at all.

StackBlitz recreated Node in WASM to fit it in your browser.

We deleted the part that needed Node.

The Experience

From Browser to Building
in 60 Seconds

No installation. No setup. No learning curve.

Type the URL

That's the entire installation process. No downloads. No installers. No system requirements beyond a web browser.

Your Desktop Appears

A familiar desktop environment greets you. Taskbar at the bottom. Toolbar on the right. Desktop shortcuts. You already know how this works — you've been using it your whole life.

Open What You Need

Click Launch. Code Manager and Deploy Manager sit at the top, and underneath them are the tools you built. Test Manager, Job Inspector, Gen AI, Architect — all made on the platform, all opened the same way. Nothing marks yours as second-class.

Write Your Code

Write HTML, CSS, JavaScript, and Python in a unified editor. Or describe what you need and let AI build it — Claude, ChatGPT, Grok, and Gemini are built right in.

Work Your Way

Open multiple tools at once. Drag them, resize them, stack them. Here Contact Manager is running in front of its own source in Code Manager — the component on the left, the working app on top of it. The taskbar tracks everything.

Save. It's Live.

Click "Push to Prod." The platform compares versions and transfers only what changed. No CI/CD. No build process. No waiting. Your code is running.