Describe your business once. Run it everywhere.
A project starts with a rulebook: your tables, fields and calculations in one readable file. The database, API, admin app and docs are generated from it. We keep it online, and you can take all of it with you at any time.
Projects are free. No card needed.
CASE WHEN days_late > 5 THEN monthly_rent * late_fee_rate ELSE 0 ENDdaysLate > 5 ? monthlyRent * lateFeeRate : 0=IF([@DaysLate]>5,[@MonthlyRent]*[@LateFeeRate],0)The late fee is the monthly rent times the late-fee rate when rent is more than 5 days late. Otherwise it is zero.Change the grace period with − and +. The rule changes once, and every generated form follows.
We turn what you already know into working software — at any scale.
Drop a rulebook, get a working repository back — that is the whole of it, and the film is fifteen minutes of it actually happening. Cost is decoupled from size by construction, not by discount.
The full walkthrough · Drop Your Rulebook Here · 15 min
The rulebook is the only thing anyone writes or edits. Change a rule, and the database, API, app, docs and tests all follow. They cannot drift, because they were never independently written in the first place.
A 500-table system and a 50-table one cost roughly the same to build. Generation is not billed by the hour against scope — it is closer to a print run than a construction project. This is the part a shop that hand-writes code cannot match.
A solo builder gets the identical core mechanism for $0, today. That is not a loss leader — it is the proof. You can watch the exact machine that builds an enterprise system build your own project first.
One free project. Add what you need.
This is a project, drawn exactly as you will see it in the app. Open the rows.
- ◆The core rulebook
Every project has one. It holds your model, and every tool reads it. Each tool's path to it is worked out for you.
- BESeeds
Packages you add: an import, a database, an app. A seed can include other seeds and the tools they bring.
- ⚙Tools
Each one turns the rulebook into something: SQL, an API, a workbook, docs.
- ▲Hosting
Press Start and the project is built and put online as a live preview. Start it again whenever you need it.
- Licenses
Any seed or tool may carry one: declared, tracked or enforced. A license governs future runs only. What you have generated is yours.
Start anywhere. Arrive at the same project.
A new project starts with an empty core rulebook. Bring your rules in when you create it, or later. It is the same step either way.
A project with a core rulebook
Ready to edit, to add seeds and tools to, and to start. However it began.
Start where you actually are.
Each page has its own short film. Or just show me the prices.
Describe it in a sentence and get the rulebook for it: every table, field and rule, written down where you can read it.
Watch the film and read more →$0–$10k+ · Most projectsOne process, and it lives in someone's head.The undocumented thing your team works around. Write it down once, get software that runs on it.
Watch the film and read more →$0–$10k+ · For dev shopsI deliver software for other people.Quote a fixed number your competitors structurally cannot match, and deliver against it.
Watch the film and read more →$10k+ · Ontology & auditEvery department means something different by the same word.Ontology, provenance and audit readiness — a system of record that survives the people who built it.
Watch the film and read more →Your project is free. You pay to keep it running.
Three things can cost money, and only one of them is per project.
Files, versions, the rulebook and every export. Always free.
Free preview runs stop after 30 minutes and restart on demand. Bigger, always-on machines are coming at a fixed monthly fee.
Most are free. Each shows its price and license before you add it.
Free
- Every project, its rulebook and every export
- Live preview runs on shared infrastructure
- A preview stops after 30 minutes; start it again any time
- One live run per project
- Export everything, any time
Pro
- Everything in Free
- Unlimited tool runs
- Unlimited private rulebooks
- 3 hosted bases
- 5 seats
Bigger hosting
A fixed monthly fee per project, for each size. Chosen inside the project.
Download your whole account as a spreadsheet.
Not just your rows: your entire model. Projects, rulebooks, seeds, the licenses you hold and the license models that compute your usage. We run our own business on a rulebook too, so this is the file we would want.
| A · License | B · Product | C · Level | D · Model | E · Used | |
|---|---|---|---|---|---|
| 2 | L-0193 | From Airtable | Tracked | 5 imports per base every 30 days | 2 of 5 |
| 3 | L-0207 | rulebook-to-xlsx | Tracked | 100 runs per month | 7 of 100 |
| 4 | L-0211 | Shared hosting | Enforced | 1 live run per project | 1 of 1 |
Know exactly what happened, after the fact.
Each run carries one hash through every step, along with the hash of the rulebook version that governed it. Each actor, a person, a tool or an AI, reports what it did and adds its result to the chain.
Nobody can fix-price code they have to type.
So we do not type it. The rules go into the rulebook once, and the database, the API, the admin app, the documentation and the tests are derived from it by the same build every time. The variable that turns everyone else's quote into a range is not in ours.
A doc, a spreadsheet, a deck, or a page of notes. Whatever you already have.
Every table, field, role and rule, written once in plain English and in a form a machine can read. You browse it before anything is compiled.
Try your edge cases. Pick what to compile it into. Pay only if you like it — then the repository is yours.
Postgres, a React app, REST and GraphQL, Python, Go, C#, RuleSpeak®, Excel, OWL — each generated from the same rules, none of them hand-maintained.
See the ecosystem →The generated targets are tested against each other for the same answers, and every derived value traces back through the graph to the rule that produced it.
See how it holds up →There is a known class of rule a model like this provably cannot express on its own. We name it up front and hand it an explicit mechanism, instead of you discovering it in month five.
Read the conjecture →Evaluating this for someone else? How the platform works is the technical read — what is generated, from what, and by which tools — and the ecosystem lists every target the same rulebook compiles to. The packages and prices on this site are generated from a rulebook too.
Every software project hits the same wall.
Business rules get encoded once, and then again, and again. Into the database, the API, the frontend, the docs. Each copy drifts. There is no single place that owns the logic — and that unknown is exactly what every estimate you have ever been given was padding for.
- 01Logic scattered across the stack
Business rules end up encoded separately in the database, the API, the frontend, and the validation layer. Each location becomes its own source of truth. There is no single place to change a rule.
- 02Changes cost more every time
When a rule changes, you have to find every place it lives, understand the blast radius, and update them all consistently. Miss one and you have a silent bug. The cost per change grows with the codebase.
- 03The model stops being the system
Without a living model, the system is what the code says it is. Each layer has its own version of the rules, written at different times, by different people. To understand the system, you excavate. Code is archaeology.
Keep your tools. Change what they point at.
This is not a replacement for Cursor, or for the Airtable base your team actually runs on. It is the layer underneath both — the one that holds the rules, so nothing above it has to.
They are genuinely good at the screen — where things go, and how the thing feels to use. They are not where a business rule should live. Point one at a codebase and every rule becomes a line buried somewhere nobody can find later.
Point it at a rulebook-enforced database instead. It carries on doing the part it is good at, on a foundation where the rules are already enforced.
This is where most of these rules already live: spread across formulas, automations and views that one person understands and nobody ever wrote down. It worked right up until the day it became the system of record.
Airtable is a first-class input, not something to flee. Point us at the base and it comes back as a rulebook you can read — and that rulebook is what builds the real database, API and app.
Every one of those numbers is a range, and the width of the range is the amount of typing nobody can predict. That is not bad estimating. It is what happens when the rules get written four times over.
We write them once. That is the whole reason we can put a single number on a card instead of a range.
Technology is a setting, not a rewrite: the same rulebook compiles onto Postgres, MySQL, Airtable, Django and Entity Framework through seeds. Want the long version? How we compare lays it out row by row, including what we don't claim.
Or run it yourself.
Everything we build your project with is open source, and it is the same engine either way — three commands and you are running it. Commercial licenses are for companies running many projects at once, and for large organizations.
- 01Add Effortless to Claude Code
Two commands install the Effortless skills.
- 02Describe your app in one sentence
Claude writes the rules and builds a working app.
- 03Change a rule
Say it in plain language. The whole app follows.
Go faster with a training session. The fee converts to credit.
Getting started on your own is free. Training is the fastest way to get it right: we walk your team through the methodology, hands-on with real tooling.
Not sure yet? Spend an hour with us. We'll look at your project, tell you honestly whether Effortless is a fit, and help you get going.
Hands-on walkthrough of the methodology and toolchain on a real project. By the end, you know exactly how to apply it on your next engagement.
Fully converted into store credit2 sessions$1,500Hands-On WorkshopBuild a real system slice from scratch - schema design, modeling surface setup, first effortless build, consuming views in app code.
$1,000 converts to store credit5 sessions$5,000Team OnboardingA complete adoption engagement for your team. Covers the full Bootstrap + Effortless Loop cycle and ends with a working, production-ready system slice your team owns.
$2,500 converts to store creditFor bigger teams and multiple projects, Deep Enablement is scoped up front as a fixed package. See training details or book a session.
Regulated gaming already runs on this.
A US state agency and a tribal gaming commission both run regulatory software built this way — the kind that gets audited. So does a live cattle auction platform, a car wash chain and a nursery group.
“EffortlessAPI upgraded our entire gaming device management system.”
“EffortlessAPI has made our entire regulatory gaming compliance operation more efficient, improving efficiency by over 250%.”
“No way we could have rebuilt CattleUSA without your expertise.”
Rather have us build it?
Bring us your spec and get one fixed price. We deliver into a project you own, as seeds you keep.
A 30-minute conversation. No form to fill in first.
- One number, not a rangeWe capture your rules first, so we can quote a fixed price for the whole build.
- Most projects need no depositYou see the rulebook before you commit to the software.
- It lands in your projectEverything we build arrives as seeds in a project on your account.