Guide November 4, 2026 · 6 min read

Building AI Apps Like an Engineer: Start Here

New to apps and AI builders? What an app is made of, the steps engineers follow to build one, and three questions to ask your AI builder.

Part 2 of 10 · Building AI Apps Like an Engineer
  • ✓ 1. Introduction: I'm learning the path
  • 2. Start here · you are here
  • 3. A plain-English glossary · coming 18 Nov
  • 4. The rules file · coming 2 Dec
  • 5. The open database · coming 16 Dec
  • 5 more planned

When I started looking into how apps get built, every conversation seemed to be in a language I hadn’t learned. Frontend. Backend. Deploy. Row-level security. People nodded along, and I nodded too.

So before this series goes any further, I want to go back to the start. This is the post I wish I’d read first: what an app is actually made of, the steps engineers follow to build one, and where AI builders fit in.

If you already know all this, skip ahead. If you don’t, you’re exactly who it’s for.

What an app is made of

The easiest way I’ve found to picture an app is one you’ve almost certainly used: a food delivery app.

Here’s the lesson that took me longest to understand. The real checks have to happen on the company’s computers, not on your phone. Imagine the app worked out your total on your phone and simply told the server “this person owes $2”. Anyone who changed that number on their own phone would eat for almost nothing. A well-built app re-checks the price, the discount and the payment on the server, where customers can’t reach.

The same goes for who can see what. Hiding a button on the screen is like a “staff only” sign on a door with no lock. It stops polite people, and only polite people. The real check, “is this person allowed to do this?”, has to happen on the server.

Most of the data leaks I’ve read about this year seem to come back to this one idea. The records were left open, or the only check was on the screen.

The steps engineers follow

Engineers don’t just write code. Building a good app takes a whole routine around the coding, and that routine has a name: the software development life cycle. Here it is as I understand it so far, using the delivery app as the example:

  1. Rules. Agree how the work is done before anyone starts: how changes are made, who checks them, what never happens. Example: no change goes live until someone else has looked at it.
  2. Requirements. Decide what you’re building. Example: customers, restaurants and drivers each see different things. The app stores addresses and payment details, so leaks would really hurt. Group orders can wait until later.
  3. Architecture. Plan which part does what. Example: the phone shows the menu, but the server works out the price and checks every order. Card details go to a payment company, never into your own records.
  4. Build. Write the code. Example: keep secret keys on the server, never inside the phone app, and change one thing at a time.
  5. Test. Prove it works, including when things go wrong. Example: what happens if the payment fails halfway, or if a customer tries to open someone else’s order?
  6. Release. Go live in a way you can undo. Example: switch the new checkout on for a few customers first, with a way to switch it straight back off.
  7. Operate. Know when something breaks before your users tell you. Example: an alert fires if orders suddenly stop coming in at dinner time.
  8. Maintain. Keep it healthy over time. Example: update the building blocks the app is made from when problems are found in them, because an app that’s safe in January can be unsafe in June without you changing a thing.

At every one of those steps, engineers ask three questions:

This isn’t just one person’s opinion

I wanted to know whether this routine is a real standard or just good habits people talk about. It turns out governments write it down.

In February 2022, the US National Institute of Standards and Technology (NIST) published its Secure Software Development Framework. It’s a guide to building software safely. It groups the work into four areas: preparing the team, protecting the software, producing well-secured software, and responding when problems are found. (NIST SP 800-218)

What caught my eye was the reason NIST gives for writing it: few software development processes cover security in detail, so these practices usually need to be added. (NIST)

In other words, even for professional teams, security doesn’t come built in. Someone has to add it on purpose. That’s worth remembering when we get to AI builders.

Where AI builders fit in

An AI app builder, like Lovable, Replit, Bolt or Cursor, squeezes most of that routine into a single conversation. You describe the app you want, and a few minutes later you can tap through it. It made the plan, wrote the code and put it online for you.

That speed is genuinely amazing, and it’s why so many people who’d never have built software are building it now. I’m one of them.

The question this series asks is simpler than it sounds: when the builder does all of that in one go, which steps does it actually do, and which does it skip unless someone asks? I have a hunch, but I’m going to check rather than assume. Each post takes one step, learns what engineers do, watches what the AI does, and tests a guardrail that makes it do the step properly.

Try this yourself (no code needed)

You can start checking your own app today. Ask your AI builder these three questions, in plain words:

  1. “In plain English, what parts does my app have? What runs in the browser, what runs on a server, and where is my data kept?”
  2. “Where does my app check that a person is allowed to see or change something? Is that check on the server?”
  3. “If a change you made broke something, how would we undo it?”

You don’t need to understand every word of the answer. Look for one thing: does it name specific places, or does it stay vague? “Every request to the orders table is checked on the server against the signed-in user” is a real answer. “Your app is secure and follows best practices” isn’t one.

If the answers worry you, that’s useful, not scary. It tells you which step to look at first, and that’s what the rest of this series is for.

What’s next

Next in this series: a plain-English glossary. All the words from this post and more, kept as a page you can come back to and growing with every post.

If there’s a word you keep hearing and never quite understood, tell me and I’ll add it. Email me at [email protected].

And if this felt like a lot: it felt like a lot to me too. That’s why I’m writing it down one step at a time.

← Previous part
Introduction: I'm learning the path
Next part →
A plain-English glossary
Coming 18 Nov
The monthly Verilay newsletter

One short email a month: what’s new at Verilay, one thing to check in your AI-built app (with a ready-to-paste prompt), and the AI security news worth knowing. No spam, and you can unsubscribe from any issue.

Verilay is free at verilay.dev — no account needed.
Paste in a GitHub link, a ZIP from Lovable or Replit, or your live app’s address, and it will tell you in plain English what your app is made of and what’s worth worrying about. The code is public at github.com/ekbm/verilay.