← The AI Builder Stack

Foundations — How Software Actually Works

Before you type a single prompt, learn what happens after you hit "sign up"

00 — Why This Layer Exists

You've opened Claude Code once. Maybe you typed something like "build me a waitlist app," watched files scroll by, and got... something. Maybe it worked. Maybe it broke and the error message might as well have been in ancient Greek. Either way, you walked away with a nagging feeling: I don't actually know what just happened.

That feeling is the whole reason this layer exists. As a senior PM, you already know how to read a spec, run a roadmap, and translate a business problem into a product decision. What you're missing isn't intelligence — it's a mental map of the machine. When an AI coding agent says "I've deployed your backend and connected it to the database," you need to know, at minimum, what a backend is, what a database is, and what "deployed" means — not to write the code yourself, but to know if the agent did something reasonable, to ask a good follow-up question, and to know what to check when something's broken.

This layer gives you that map. No code. Just the five or six ideas that everything else in this series — prompting, no-code builders, agentic tools, hosting, testing — assumes you already have.

01 — Client vs. Server: Two Computers, Not One

Almost every app you use involves at least two computers talking to each other, even though it feels like one seamless thing.

The client is the device in front of you — your phone, your laptop, your browser tab. It's what you see and touch: buttons, screens, text fields. The client's job is to show you things and collect what you type or tap.

The server is a computer somewhere else — usually in a data center you'll never see — that the client talks to over the internet. The server's job is to do the heavier lifting: check passwords, run business logic, store and retrieve data, and send answers back.

Here's the key mental shift: when you use an app, you are almost never interacting with "the app" as a single thing. You're interacting with a client that is constantly having short conversations with a server, over and over, usually in well under a second each time. Every tap can trigger one of these conversations.

02 — Frontend vs. Backend

These terms map closely to client and server, but describe the code, not the machines.

  • Frontend is the code that runs on the client — the layout, the buttons, the colors, what happens when you tap something. If you've used a no-code tool to change a button's color or move a field on a screen, you were touching the frontend.
  • Backend is the code that runs on the server — the rules for what's allowed, how data gets saved, how a password gets checked, how a payment gets processed.

A useful test: if it's about what you see and interact with, it's frontend. If it's about what happens out of sight, on someone else's computer, it's backend. A single "app" is really always two coordinated codebases pretending to be one.

03 — What a Database Actually Is

A database is where an application's data lives permanently — the organized, searchable storage that survives after you close the app. Every user account, every order, every message, every "like" is a row of data sitting in a database somewhere on a server, not on your phone.

Think of it like a very strict, very fast spreadsheet system. There are tables (like sheets) with columns (like "email," "name," "signup date") and rows (one row per user, per order, per whatever). The backend is the only thing that's supposed to talk directly to the database — the frontend asks the backend for data, and the backend fetches it.

Why does this matter to you as a PM? Because "where does this data live, and who can read or change it" is a product and security question you'll be making decisions about constantly — and it's meaningless without knowing that a database is a separate, persistent thing from "the app."

04 — What "Calling an API" Actually Means

An API (Application Programming Interface) is, in plain terms, a defined way for one piece of software to ask another piece of software to do something — a contract that says "here's what you're allowed to ask me for, and here's exactly how to ask." (MDN's Web Docs put it simply: an API is a set of rules and features that let software communicate with other software, the same way a user interface lets a human interact with software.)

"Calling an API" in practice usually means: the client sends a small, structured request to a server — a URL, a method (like GET to fetch something or POST to create something), and sometimes a chunk of data — and the server sends back a structured response, often in a format called JSON (a plain-text way of writing data as labeled fields, like {"name": "Alex", "email": "alex@example.com"}).

So when someone says "we're calling the Stripe API to process this payment," they mean: our backend sends a structured request to Stripe's servers, in the format Stripe requires, and Stripe sends back a structured answer ("payment succeeded" or "card declined"). You will call APIs constantly once you're building — to check a user in, to charge a card, to send an email, to ask an AI model for a response. It is the universal handshake of modern software.

05 — What "Hosting" and "Deploying" Mean

When you build something on your own laptop, it only exists on your laptop — nobody else can reach it. Deploying means taking that application and putting it on a server that's reachable over the internet, running continuously, instead of only running on your machine while you have it open. Hosting refers to the ongoing service of keeping that server available — a company (like Vercel, Render, Railway, AWS, or many others) rents you computing space so your app has somewhere to live 24/7.

A domain name (like yourapp.com) is what people type into a browser. Behind the scenes, a system called DNS translates that human-readable name into the technical address of the server hosting your app, so the browser knows where to send its requests. This is why people say a URL "points at" a server — literally, typing that address tells DNS where to route the request, and DNS hands it off to whichever server is hosting your app.

The practical upshot: "is it deployed?" is really asking "does this app now live on a server with a real address, reachable by anyone, all the time — not just when I have it open on my laptop?"

06 — How to Actually Use This: Tracing One Tap End-to-End

Let's walk through what happens, machine by machine, when someone taps "Sign Up" in an app you built.

Step What happens Which piece is doing it
1 User types their email and password into a form and taps "Sign Up." Client / frontend — this is just a screen collecting input, nothing is saved yet.
2 The app packages that email and password into a structured request and sends it over the internet. API call — the client is "calling" an endpoint (a specific URL) that the backend has set up to handle new signups, e.g. /api/signup.
3 That request arrives at a server somewhere, currently running the app's backend code. Server / backend — the request only gets here because the app is deployed and hosted; if it weren't, there'd be nothing at that URL to answer.
4 The backend checks: is this email already taken? Is the password strong enough? It may also scramble ("hash") the password so it's never stored in plain readable text. Backend logic
5 The backend saves a new row — email, hashed password, signup date — into a table of users. Database
6 The backend sends a response back to the client: "success," maybe with a token that proves the user is now logged in. API response
7 The client receives that response and updates the screen — maybe showing a welcome page or the app's home screen. Client / frontend

Notice what just happened: a single tap triggered a full round trip — client to server, server to database, database back to server, server back to client — typically completing in well under a second. If any single link breaks (the server is down, the database rejects a duplicate email, the request times out because of a network hiccup), the user just sees "something went wrong," and figuring out which link failed is the essence of debugging, which Layer 09 covers in depth.

When you're working with an AI coding agent later in this series, it will be doing exactly this kind of wiring for you — writing the frontend form, the backend endpoint, and the database table, and connecting them. Knowing this sequence means you can ask it targeted questions: "did you create the endpoint that handles this?" "Where is the password being checked?" "What database table does this write to?" — instead of just hoping it worked.

07 — A Glossary You'll Keep Hearing

Term Plain-English meaning
Repo (repository) A project's folder, tracked over time — every file plus a history of every change made to it, so people (or AI agents) can collaborate without overwriting each other's work. (GitHub describes it as "a place where you can store your code, your files, and each file's revision history.")
Endpoint A specific address on a server that's built to handle one kind of request — like a doorbell for one particular function (e.g., "sign up," "get my orders").
Environment A separate copy of your app used for a specific purpose — commonly "development" (where you build and break things safely), "staging" (a rehearsal copy that mimics production), and "production" (the real, live version real users touch).
Framework A pre-built set of tools and conventions that handles common, repetitive plumbing (like routing requests or rendering screens) so builders don't reinvent it every time — a scaffold you build inside, not a blank page.
Stack The particular combination of technologies an app is built with — e.g., a certain frontend framework, backend language, and database, bundled together as "the stack" you're using.
Client The device/software the user directly interacts with (browser, phone app).
Server The remote computer that processes requests and talks to the database on the client's behalf.

08 — Common Mistakes Beginners Make

  • Thinking "the app" is one thing. It's always at least two: a frontend and a backend, often built and even hosted separately, that only feel like one thing because they talk to each other so fast.
  • Assuming data lives "in the app." It doesn't — it lives in a database on a server. Uninstalling the app on your phone doesn't delete your account; the database still has your row.
  • Confusing "it works on my laptop" with "it's live." An app running locally isn't deployed. Nobody else can reach it until it's hosted somewhere with a real address.
  • Treating an API as magic. It's just a structured request-and-response conversation, following rules set in advance — nothing more mystical than filling out a very specific form and getting a specific kind of reply back.
  • Not distinguishing environments. Testing changes directly against "production" (the real live app with real users) instead of a safe "staging" or "development" copy is one of the most common — and most avoidable — ways beginners cause real damage.

Where This Leads

You now have the map: client and server, frontend and backend, database, API calls, and what it means for something to actually be live on the internet — plus the vocabulary (repo, endpoint, environment, framework, stack) you'll hear constantly from here on. None of this required writing a line of code, but all of it is what lets you read an AI coding agent's actions and know whether they make sense. Layer 01 — Spec-to-Prompt — picks up exactly here: now that you know what gets built, you'll learn how to describe what you want built clearly enough that an AI agent can act on it correctly the first time.