Flare, as presented

JS Meetup · 2026

Flare Framework

The fastest way to ship a full-stack app on Next.js or Cloudflare.

Muke JohnBaptist · Desishub

Who is telling it

Muke JohnBaptist (JB)

Fullstack engineer · Kampala, Uganda

• Founder of Desishub Technologies
• 30+ client projects shipped across four countries
• 30+ products sold online — $19k in product sales alone
• DGateway — MTN, Airtel and Stripe payments, over 100M in transactions
• Flare — the framework this talk is about
• Grit — its Go sibling
• 10,310 contributions across 567 repositories — 12+ open source projects
• JB WEB DEVELOPER on YouTube — 16K subscribers

github.com/MUKE-coder · @JBWEBDEVELOPER · jb.desishub.com

And what I do when nobody is paying me

Thirteen are open. All take pull requests.

• Grit1,288 commitssitecode
• Flare234 commitssitecode
• Scout142 commitssitecode
• Orbita107 commitssitecode
• Vibekit91 commitssitecode
• JEditor83 commitssitecode
• Simple UI79 commitssitecode
• Sentinel47 commitssitecode
• Pulse40 commitscode
• Zenith34 commitssitecode
• GORM Studio28 commitssitecode
• Beautiful Banner Ads20 commitsnpmcode
• Optimised Uploadsnpm

Over two thousand commits, MIT, and every one has issues nobody has taken — including this one.

A show of hands

Who here builds with Next.js?

Keep them up.

Second question

Why do you love it?

Shout them out.

The answers that always come up

And it's all true

Next.js earned this room.

So nothing tonight is against it. Tonight is about what happens after you pick it — on day one of a real project.

If you have built full-stack, you know this feeling

The blank canvas.

A new client. An empty folder. And you already know everything this project owes you before the first feature: auth, a database, an admin, uploads, roles, a deploy.

Because a real project

comes with a to-do list
nobody put on the quote.

Six of them. Every one is work you have done before, and not one of them is the thing the client is paying for.

The list

Your six

The developer problems. You have met every one of them.

Developer problems · the top six

Your six · 01

Your six · 02

Your six · 03

Your six · 04

Your six · 05

Your six · 06

The honest answer to all six

“Yes — in about three weeks.”

Which the client hears as a no. So the security, the audit and the polish are promised for phase two — and phase two never arrives.

So

What if there were a different way to start?

Not a different framework. A different first day.

Introducing

Flare

The fastest way to ship a full-stack app on Next.js or Cloudflare.

Wait — a framework?

Why that word makes you flinch

• Breaking changes every major version
• Abstractions you end up fighting
• Magic you cannot debug
• Lock-in you cannot leave
• And the rewrite when it dies

Every one of these is a scar, not a hypothetical.

So here is the deal

Flare's answer to all five

• Nothing of Flare runs in production
• Plain Next.js code, in your repo
• The engine: ~800 readable lines, copied into the app
• Upgrades are a diff you read, not a version you pray over
• Delete the CLI — the app still builds

No runtime to be trapped by, because there is no runtime.

So, honestly

Flare, the framework

Delete the CLI tomorrow, and your code keeps working. That is the test — and it is the whole philosophy in one sentence.

What it actually is

A code generator — from a proud old family.

Rails gave us scaffold. Django gave us the admin. Laravel gave us artisan make. Twenty years of proof that generating the boring parts works.

The difference

Where the family stopped

• scaffold gives you a model and a controller — one layer
• The admin lives inside the framework, not in your code
• Regenerate, and your edits are overwritten
• One language, one runtime, their server

Flare keeps going on all four. The first one is the big one.

Where Flare keeps going

One command writes the whole vertical slice

• The model — schema, migration, validators, types
• The controller — a REST API, with auth and roles already on it
• The view — list, create, edit and detail pages, and the forms
• Plus the parts MVC never named: a typed client, hooks, seeds, a policy file

Full MVC and then some, in your repository — and your edits are detected as drift, never lost. The same description deploys to Next.js or Cloudflare.

Step zero · install

npm install -g @flaredev/cli

flare --version

Node 22+, and that is the whole install. Or skip it: every command below runs through npx flare with nothing installed.

Step one · create the app, on either stack

# Next.js on Vercel — the default
pnpm create flare-framework clinic
cd clinic

# Cloudflare Workers — one flag
pnpm create flare-framework clinic --stack cloudflare
cd clinic

One flag is the entire difference at the command line. create scaffolds a working app either way: sign-in, a database, an admin shell and the bindings — before any resource exists.

What that one flag changes · two stacks, one description

Everything else — auth, the dashboard, your descriptors, hooks, components — is identical.

Start small

Two tables.
Two commands.

Before the real brief, the smallest app that is still an app.

The brief

A contacts app.

Groups have a name. Contacts have a name, a phone and an email, and belong to a group. That is the entire specification.

Design the tables — which is the only real thinking here

Two tables. Read them aloud and you have already written the commands — that is the whole method, and the clinic later is the same thing seven times.

Transcribe them

npx flare gen resource Group \
  --fields 'name:string!'

npx flare gen resource Contact \
  --fields 'name:string, phone:tel?, email:email!, group:belongsTo(Group)?'

Groups first: a belongsTo needs something to point at. ! is unique, ? is optional, tel and email validate themselves.

That command, piece by piece

npx flare gen resource <Name> --fields '<field>:<type><modifiers>, …'
          ╰── verb ──╯ ╰name╯          ╰───── the table design ─────╯

# the one you just ran
npx flare gen resource Contact \
  --fields 'name:string, phone:tel?, email:email!, group:belongsTo(Group)?'

Contact becomes the contacts table, /api/contacts, and Contacts in the sidebar — you name it once. Two optional flags decide where it sits: --icon and --group.

And inside the quotes

`<field>:<type><modifiers>`

Four fields, four decisions, one line. Every type there is comes two slides from now — these are the four you need to read anything else in this talk.

Those two commands wrote

Twenty files. None of them by hand.

Two tables and their migrations. Validators. Eight API routes. A typed client. Eight admin screens — list, create, edit, detail, each with a loading skeleton shaped like it. And a policy, admin-only until you open it.

Run it

npx flare migrate
npx flare seed:resource Group 5
npx flare seed:resource Contact 40
npx flare dev

localhost:3000 — sign in, and there is a contacts app: a group picker, a working email field, tables that sort, filter, page and export.

So — the uncomfortable question

How long would those two tables have taken you?

Not the thinking. The typing: the schema, the migration, the validation, the routes, the forms, the list with its empty state. An afternoon, honestly, and you have built it before.

The field grammar · one sentence per table

Half the language. One more slide, then we take them one at a time.

The field grammar · and the rest of it

Ten rows across two slides, and that is the whole language. Everything else in Flare is derived from it.

Field 01 · text

string, text, markdown

string when it fits on a line, text when it does not, markdown when someone will want a heading and a link.

Field 02 · the formats

Text that knows what it is

Every one is a text column — the format picks the validator, the keyboard and the widget. Also slug domain username ip uuid timezone locale postcode.

Field 03 · numbers

int, float — and the three shorthands

money is the one that matters: never a float. 19.99 cannot be represented exactly in binary, and a clinic's invoices are not the place to discover that.

Field 04 · boolean

A yes or a no

The table column renders it as a badge rather than the word “true”, and the filter bar gets a yes/no toggle for it without being asked.

Field 05 · dates

date, datetime

date for a birthday, datetime for an appointment. A birthday with a timezone is how someone ends up a day older in Kampala than in London.

Field 06 · closed lists

enum, radio, multiselect

The database refuses a fourth value — so next year's typo fails loudly instead of quietly adding a status nothing handles.

Field 07 · the open-ended two

tags, json

tags when the list is open but the values are words. json when you genuinely do not know the shape yet — and knowing you will regret it later is part of choosing it.

Field 08 · uploads — the one with the most hidden work

The cap is checked twice — in the browser, and on the server against the real bytes. The browser is not a security boundary.

Field 09 · relations

belongsTo, hasMany

You write patient, Flare writes patientId. The index comes with it, which is the line between a list page that stays fast and one that quietly does not.

Field 10 · the two marks, and the clause

! ? and if

Two characters each. Between them they cover most of what you would otherwise write a validator for — and because unique is a database constraint, a race between two requests still cannot create a duplicate.

Prove it

A Patient
Management System

A real brief, built the Flare way, in front of you.

Same question, seven times the size

And how long would this one take?

Patients, doctors, appointments, visits, prescriptions, invoices, payments. Auth, admin, uploads, roles, deploy. Think of your real number — with meetings in it.

The Flare way

Understand three things: the tables, their fields, and how they relate.

That is the real work — and you were always going to do it. You just did it for contacts in thirty seconds. Flare's job is to translate that understanding directly into code.

The design: seven tables

The whole system

Table 1 of 7 · patients

The person

patients · as a command

npx flare gen resource Patient --icon user-round --group Clinic \
  --fields 'name:string!, phone:tel!, dateOfBirth:date,
            sex:enum(female,male),
            photo:file:[image]:5mb?, allergies:text?'

tel validates per country. ! on phone: unique. file:[image]:5mb? is the bucket, the signed URL, the size cap and the leading-bytes check — optional, because not everyone has a photo.

Table 2 of 7 · doctors

Who sees them

doctors · as a command

npx flare gen resource Doctor --icon stethoscope --group Clinic \
  --fields 'name:string!, email:email!,
            specialty:enum(gp,paediatrics,dental,gyn,surgery),
            licenceNumber:string!, active:boolean'

email is a type of its own: format validation and a mailto link in the admin. Two ! fields — two unique constraints.

Table 3 of 7 · appointments

The booking — and the first relationship

appointments · as a command

npx flare gen resource Appointment --icon calendar-clock --group Clinic \
  --fields 'patient:belongsTo(Patient), doctor:belongsTo(Doctor),
            scheduledFor:datetime,
            status:enum(booked,arrived,seen,cancelled,noShow),
            cancelledBecause:string if status == cancelled'

belongsTo is the foreign key, its index, and a searchable picker in the form. The if clause is checked at generation time: cancelled must be one of the statuses, or no file is written.

That if clause, in full

One clause. Three behaviours. Zero disagreements.

The form shows the field only when cancelled. The validator requires it only when cancelled. And when a booking is edited away from cancelled, the store clears it — so last week's reason never haunts the row.

Table 4 of 7 · visits

What actually happened

visits · as a command

npx flare gen resource Visit --icon clipboard-list --group Clinic \
  --fields 'appointment:belongsTo(Appointment),
            complaint:text, diagnosis:string,
            followUp:boolean,
            followUpOn:date if followUp == true'

text is the long-text column with a textarea; string the short one. The conditional date works exactly like the cancellation reason.

Table 5 of 7 · prescriptions

What was given

prescriptions · as a command

npx flare gen resource Prescription --icon pill --group Clinic \
  --fields 'visit:belongsTo(Visit), drug:string!,
            dosage:string, frequency:string, days:int'

int is a whole number: integer column, stepper input, no decimals accepted.

Table 6 of 7 · invoices

What it costs

What a float thinks money is

0.07 + 0.07 + 0.07 = 0.21000000000000002

Found months later, by whoever reconciles the bank statement. Fixed with a migration and a data repair, in production.

invoices · as a command

npx flare gen resource Invoice --icon receipt --group Clinic \
  --fields 'patient:belongsTo(Patient), visit:belongsTo(Visit),
            amount:money,
            status:enum(draft,sent,paid,overdue)'

money stores whole minor units — the column only ever sees 120050. The API and forms still speak 1200.50; three extra decimals are a 422, not a silent rounding.

Table 7 of 7 · payments

What was paid, and how

payments · as a command — the last one

npx flare gen resource Payment --icon hand-coins --group Clinic \
  --fields 'invoice:belongsTo(Invoice), amount:money,
            method:enum(cash,mobileMoney,card,insurance),
            claimNumber:string if method == insurance'

Seven tables, seven sentences. Every flag on every command was a row in a table you designed.

And each of those seven commands wrote

The schema. The migration. Validators. The API. A typed client. Four admin pages.

Twenty files per table, into your repository — the whole vertical slice, with loading skeletons shaped like each screen. The CRUD hell, generated out of existence.

Step by step

From commands
to a running clinic

Migrate, seed, run, share, deploy — in order.

The whole path

Step 03 · the database catches up

$ flare migrate

  0000_init.sql                 ✓
  0001_create_patients.sql      ✓
  0002_create_doctors.sql       ✓
  …
  0007_create_payments.sql      ✓

Plain SQL migrations, written by the generator, applied in order. Readable in review like any migration you wrote yourself.

Step 04 · flare seed demo

A clinic that looks like a clinic.

Realistic patients, bookings and invoices — not three rows named “asdf”. Friday's demo stops being a liability the moment the data looks true.

Step 05 · flare dev

localhost:3000 — and the admin is already there.

A sign-in page. A sidebar with seven resources. Tables that sort, filter, page and export. Forms with the pickers and the conditional fields. Nobody has opened a component file.

Step 06 · the first sign-up

The first account becomes the admin.

Every resource arrives admin-only, enforced by the API and the admin UI from the same policy file. A patient record open to anyone who registers is not a bug you want to find in a clinic.

Step 07 · flare dev --tunnel

Show it before you ship it.

Your local app on a public HTTPS link — no account, no DNS, no open ports. The client sees Friday's demo on Wednesday, from their own phone.

Step 08 · the last command — on Cloudflare

$ npx flare deploy

flare  Applying migrations to clinic-db (remote)
       0001_create_patients.sql ✓  …  0007_create_payments.sql ✓
flare  Deploying
       Uploaded clinic
flare  Generating BETTER_AUTH_SECRET for production

Deployed to https://clinic.you.workers.dev

Migrations, the deploy, then any secret you forgot — generated, not googled. Nothing to click on a dashboard.

The same command, two honestly different jobs

Vercel already owns the build, the env and the project — so Flare does not pretend to.

And remember “cheap to run”?

The same seven commands, the same descriptors, either home. Pick for the database — everything else travels.

So — the number you thought of earlier

The tables took longer than the app.

And the tables were the real work all along. Seven commands, a migrate, a seed, a deploy: the rest of your estimate is now features.

One more thing

And if you build
with an agent

Which, let us be honest, is most of us now.

Why Flare and agents get along

Less code to write, more structure to follow.

An agent's two failure modes are inventing structure and writing too much of it. Flare removes both: the structure is fixed, and two-thirds of the code is generated before the agent starts.

But an agent that has never seen Flare

…will fight it

• Hand-edits the generated blocks, and loses the work on the next flare gen
• Checks roles in the component instead of the policy file
• Reaches for wrangler in a Next.js app, or Prisma in a Cloudflare one
• Writes the CRUD you already had, by hand, confidently

None of that is the agent being bad. It is the agent guessing, because nobody told it.

So we wrote it down — as a skill

npx skills add MUKE-coder/flare-framework@flare

One command. It installs a skill your agent loads the moment it notices it is in a Flare app — and it works in Claude Code, Codex, Copilot, Cursor and OpenCode, because the installer puts it where each one looks.

What is in it

Everything you have just watched me explain

• The full CLI reference, per stack
• The field grammar — every type on those ten slides
• The seven rules, each with the reasoning, so it knows when they bend
• Recipes: relations, uploads, search, auth, billing, policies
• And the overwrite contract, so it never hand-edits a generated block

The agent does not get smarter. It stops guessing about the things with one right answer.

Three ways in, pick any

If you do not want a skill installed

• llms.txt — every docs page as one list, in the llmstxt.org format. Point an agent at it
• The Build with AI button at the foot of every docs page — copies a full brief to paste into a fresh chat
• Or the skill, which is the same knowledge, loaded automatically

All three carry the same content, generated from the same docs — so a page that exists is a page your agent can find.

The honest division of labour

A mistake in a generated file is a compile error. A mistake in a policy file is a security bug — so that is the third you read line by line.

Before you believe all of it

A framework that only lists its strengths is asking you to find the weaknesses yourself, on your own project, at your own cost.

Which brings me to the real ask

Flare needs people who will stay.

It is MIT. It is one maintainer. The roadmap is public and bigger than one person: multi-tenancy, field-level permissions, a plugin system. A project becomes real the day it stops being one person's.

Where to start, tonight

And tonight

pnpm create flare-framework clinic

Node 22 and pnpm. By the time the kettle boils, you are signing in to your own admin — and you already know all seven commands that come next.

Thank you

Flare

pnpm create flare-framework clinic · flare-docs.codetotech.com · github.com/MUKE-coder/flare-framework

Muke JohnBaptist