Makesso

Why we built Makesso, a secure AI app builder your team can trust

Most AI app builders leave security to the code the AI writes. Here's why we built Makesso, a secure AI app builder, the other way round.

Scott @ Makesso6 min read

Most small businesses run on spreadsheets and goodwill. The stock list lives in one shared sheet, the jobs board in another, and the customer list in a third that everyone is a little afraid to sort. It works, until it doesn't: two people edit the same cell, someone shares the whole file to show one row, and nobody is quite sure which copy is current.

The obvious fix is a proper app, with a real database, a screen for each job, and sign-in so each person sees what they should. Until recently that meant a developer, a budget and a few months. Now an AI app builder can produce something that looks finished in a couple of minutes.

But "looks finished" and "safe to run your business on" are very different things. We built Makesso to be a secure AI app builder: one where the apps it makes are safe to run your business on, not just quick to make.

The demo is the easy part

Here's Makesso building a job tracker for a plumbing business from a single sentence: a pipeline board, customers, invoices and a revenue chart. It took 2 minutes 16 seconds in real time.

A real Makesso session, sped up from 2:16 to 28 seconds.

Any good AI app builder can make a screen like that. The hard part of a business app isn't the screen. It's the questions underneath it:

  • Who is allowed to see this row?
  • Can a customer see another customer's orders if they change one number in the address bar?
  • What happens to the data when someone tries something the app didn't expect?
  • When the app changes next week, does the data come with it?

In a spreadsheet those questions mostly don't get asked. In an app they're the whole point: you build one precisely so the right people see the right things.

Where most AI app builders put security

Most AI app builders generate two things: the screens, and the rules for the database behind them. Those rules, often called row-level security policies, decide who can read and change each table. They're written by the same AI that wrote the screens, in the same few minutes, and they're rarely reviewed by a person.

That's a fragile place to put the most important part of the app. A rule that is almost right looks exactly like one that is right. Forget one table and its data is open to anyone who knows where to look. Write a rule for the happy path and it may not hold when someone sends a request the app never would. And because each app's rules are written fresh, every app is a new chance to get it wrong.

None of this is the AI being careless. Writing correct access rules is hard for experienced developers too, which is exactly why it shouldn't depend on getting generated code right every single time.

Diagram: in a typical AI app builder the AI writes the access rules for one shared database; in Makesso, a secure AI app builder, the platform checks every request and builds a sandbox with only that person's data.
Same AI-written screens; the difference is who decides what each request can see.

What makes an AI app builder secure: the platform, not the AI

Makesso turns that around. The AI builds the app: the screens, the logic, the charts. It doesn't decide who can see what. The platform does, on every request, whatever the app's code says.

In practice:

  • Every query runs in its own sandbox. When someone uses an app, their request runs in a database instance that only contains the data that person may use, read-only where they may only read. A table they shouldn't see isn't hidden behind a rule; as far as their request is concerned, it doesn't exist.
  • "Each person sees only their own rows" is built in. Personal data, such as someone's own orders or settings, lives in a separate store per person, so it can't leak through a missing filter.
  • Public apps can't be wiped by strangers. For things the public adds to, like a leaderboard or a guestbook, each person can only change the rows they added. That's enforced by the platform too, not by the app.
  • An app can never do more than its owner. Sharing an app shares the app, not the rest of your data, even when someone with more access opens it.
  • The AI works in a sandbox. Makesso's own agent sees only the app it is building, has no internet access beyond our API and the package registry, and never holds your API keys.
Sharing an app with a team, then turning on sign-in so customers get their own accounts. Who sees what is enforced by the platform.

The result is that a mistake in generated code can break a screen, but it can't hand one customer's data to another. We'd rather you never had to think about any of this, but you can read how Makesso's security works in detail.

What an AI app builder for business needs beyond security

Security is the foundation, but it isn't the only gap between a demo and a tool your team relies on:

Your real data. Most teams don't start from scratch: they start from a spreadsheet. Makesso imports Excel and CSV files, including messy ones with several sheets, and documents what's in them so the AI builds on what your data actually means. See turning a spreadsheet into an app.

Sign-in for your own users. Business apps often serve people outside your account: customers, contractors, members. Apps can have their own sign-in with passwords, email codes or Google, and roles that decide what each person may see and change.

Changes you can undo. Every change the AI makes is saved as a version you can compare and go back to. On Pro, apps can have staging and production: changes are tried out on synthetic data that has the shape of your real data without any of its contents, and nothing reaches your team until you publish.

Knowing where your data lives. Everything is stored in the EU, in Paris, and AI calls on our key go only to providers that don't train on or keep your prompts. Here's exactly what we store and for how long.

Your choice of AI. Credits are included on every plan. You can also bring your own key for OpenAI, Anthropic, OpenRouter or a private endpoint, or on Pro, build straight from the assistant you already use, such as Claude, ChatGPT or Cursor, so your existing subscription does the work. The docs explain how to connect.

What you can build today

Three apps we built with Makesso are live for anyone to try. Open them on your phone too: they're built to work there.

Stack Up, a 3D block stacking game built with Makesso, with a live global leaderboardStack Up: a one-tap 3D stacking game with a live global leaderboard that strangers can add to but can't wipe. Pixel Wall, a shared real-time pixel canvas built with MakessoPixel Wall: a shared canvas everyone paints together, live. Brightline Ops, an operations app for a heating and cooling firm built with MakessoBrightline Ops: dispatch, jobs, customers, invoices and stock for a heating and cooling firm.

They're the kind of thing we built Makesso for: tools that look good, work on a phone, update live, and keep each person's data where it belongs. Teams use the same approach for inventory apps, client portals and job trackers.

What we don't promise

We'd rather be specific than impressive. Makesso doesn't write perfect code: the AI makes mistakes, sometimes takes a few rounds to fix them, and a budget model makes more of them than a premium one. It doesn't replace a development team for a large product. What it does promise is narrower and, we think, more useful: the mistakes it makes stay inside the app, and don't become a hole in who can see your data.

Try it

Makesso is free to start, with AI credits included and no card needed. Describe the app your team needs, or upload the spreadsheet you're running on today, and see what comes back.

Start building for free, or see what's in each plan.

Scott @ Makesso

The tool your team keeps asking for is one sentence away.

Start free. Describe it, watch it build, and share it with your team before lunch.

No credit card. Free plan forever.