Common Development Terms
When you're vibe coding an app, you'll hear a lot of technical jargon thrown around. This page explains the most common ones in plain English — no computer science degree needed.
Think of this as your translator for developer-speak.
A
API Key
A secret password that lets one app talk to another. When your app needs to use a service (like sending emails or processing payments), the API key proves your app is allowed to use that service.
Important: API keys are like passwords to your bank account. Never share them publicly, never post them on GitHub, and never paste them into a frontend app. If someone steals your API key, they can use the service on your dime.
Example: Your app needs an API key to use Stripe (payment processing) or SendGrid (email sending).
Authentication (Auth)
The process of verifying who someone is. It's the digital equivalent of checking someone's ID before letting them into a building.
Example: When you log into an app with your email and password, that's authentication. "Prove you are who you say you are."
Authorization (Authz / Access Control)
What a user is allowed to do after they've logged in. Authentication proves who you are; authorization decides what you can access.
Example: A regular user can view their own profile, but only an admin can delete other users' accounts. That's authorization.
B
Backend
The part of your app that runs on a server — the engine room. Users never see it, but it's where the real work happens: storing data, processing payments, sending emails, etc.
Simple way to think about it: The frontend is the restaurant's menu and dining area. The backend is the kitchen — customers don't see it, but that's where the food gets cooked.
Branch (Git Branch)
A separate copy of your code where you can make changes without affecting the main version. Think of it like a "draft mode" for your code.
Example: You create a branch called "new-login-page" to work on a new login feature. Your main app keeps running normally while you experiment. When you're done, you merge the branch back in.
Build
The process of turning your code into something a browser or phone can actually run. Some code needs to be "compiled" or "bundled" before it works.
Example: You write code in a fancy modern language, but the build step converts it into a format that web browsers understand.
C
Cache
A place where your app stores copies of frequently-used data so it loads faster. Instead of fetching the same information over and over, the app grabs it from the cache — like leftovers in the fridge instead of cooking a new meal every time.
Example: Your website's logo doesn't need to be downloaded from the server every time someone visits a page. The browser caches it, so it loads instantly on the second page.
CDN (Content Delivery Network)
A network of servers around the world that store copies of your website's files (images, videos, CSS). When someone visits your site, the CDN serves the files from the server closest to them, making your site load faster.
Simple way to think about it: Instead of everyone in the world flying to your one kitchen to get food, CDNs are like local restaurants that already have your menu ready. Much faster.
Examples: Cloudflare, Fastly, Amazon CloudFront.
CI/CD (Continuous Integration / Continuous Deployment)
An automated pipeline that tests your code and puts it live on the internet — often with a single click or even automatically. It's like having a robot assistant that checks your work and ships it to customers.
Simple way to think about it: You write code, push it to GitHub, and CI/CD automatically runs tests, builds the app, and deploys it to your server. No manual steps.
Examples: GitHub Actions, Vercel, Netlify, Cloudflare Pages.
CLI (Command Line Interface)
A text-based way to control your computer by typing commands instead of clicking buttons. Developers use it because it's faster and more powerful than graphical interfaces for many tasks.
Simple way to think about it: Instead of clicking "File > Save As", you type save myfile.txt. Scary at first, but incredibly efficient once you get used to it.
Cloud
A fancy word for someone else's computer that you rent over the internet. Instead of buying and maintaining your own physical servers, you pay a company like AWS, Google Cloud, or Cloudflare to run your app on their machines.
Example: Your app's data isn't stored on your laptop — it's stored "in the cloud," meaning on servers in a data center somewhere.
CMS (Content Management System)
A tool that lets you manage your website's content without writing code. You log into a dashboard, edit text, upload images, and publish pages — like using a fancy version of Google Docs for your website.
Examples: WordPress, Sanity, Strapi, Contentful.
Commit (Git Commit)
A saved snapshot of your code at a specific point in time. Like hitting "Save As" with a timestamp and a note about what you changed.
Example: You finish adding a new feature, so you "commit" your changes with a message like "Added user registration form." You can always go back to this snapshot later.
CORS (Cross-Origin Resource Sharing)
A security rule that browsers enforce to prevent one website from stealing data from another. It's like a bouncer checking IDs before letting apps talk to each other.
Why you'll hear about it: When your frontend tries to talk to your backend and they're on different domains, CORS errors pop up. It's annoying but it's there to protect your users.
CRUD (Create, Read, Update, Delete)
The four basic operations almost every app does with data. If your app stores anything (users, products, orders), you're doing CRUD.
| Operation | What it does | Example |
|---|---|---|
| Create | Add new data | Signing up a new user |
| Read | View existing data | Showing a user's profile |
| Update | Change existing data | Editing your profile name |
| Delete | Remove data | Deleting your account |
D
Database
A structured place where your app stores information — user accounts, orders, products, messages, etc. Think of it as a super-organized Excel spreadsheet that your app can query instantly.
Examples: PostgreSQL, MySQL, SQLite, MongoDB, Supabase.
Database Migration
A controlled way to change your database structure without losing data. When you add a new feature that needs a new table or column, you write a migration instead of manually editing the database.
Simple way to think about it: Instead of demolishing your house to add a room, a migration is like building an extension while the rest of the house stays livable.
DNS (Domain Name System)
The phonebook of the internet. When someone types your domain name (like myapp.com), DNS translates it into a numeric IP address (like 192.168.1.1) that computers actually use to find each other.
Simple way to think about it: You remember "google.com" — your computer remembers "142.250.80.46." DNS is the translator between the two.
Docker / Container
A standardized package that contains everything your app needs to run: code, settings, dependencies. Containers ensure your app runs the same way on your laptop, your teammate's computer, and the production server.
Simple way to think about it: Instead of giving someone a recipe and hoping they have all the ingredients, you give them a frozen meal — everything's included, just heat and serve.
Domain
Your website's address on the internet — what people type into their browser to find you. You buy domains from registrars and usually pay yearly.
Examples: google.com, my-awesome-app.io, yourbusiness.co
Dotenv / Environment File
A file (usually called .env) where you store secret configuration values like API keys, database passwords, and other sensitive settings. This file should never be shared or uploaded to GitHub.
Example: Your .env file might contain:
DATABASE_PASSWORD=supersecret123
STRIPE_API_KEY=sk_live_abc123
E
Endpoint
A specific URL where your app's API can be reached. Each endpoint does one thing — like fetching users, creating orders, or processing payments.
Example: https://yourapp.com/api/users might be the endpoint that returns a list of users. https://yourapp.com/api/login might be the endpoint that handles login.
Environment (Dev / Staging / Production)
Different copies of your app for different purposes:
| Environment | What it's for |
|---|---|
| Development (Dev) | Where you build and test new features — only you see it |
| Staging | A copy that looks exactly like the live app — for final testing before launch |
| Production (Prod) | The live app that real users access |
Why it matters: Never test new features directly on production. That's like performing surgery on a patient while they're running a marathon.
Environment Variables
Settings that live outside your code — like API keys, database URLs, and configuration values. They change depending on where your app is running (your laptop vs. the live server).
Simple way to think about it: Your code is a generic instruction manual. Environment variables are the specific details that make it work in each location — like "which database to use" or "what secret key to sign tokens with."
F
Firewall
A security guard for your server that blocks unwanted traffic. It decides which connections are allowed in and out of your network.
Example: You can configure a firewall to only allow traffic from certain countries, block known attackers, or only let specific IP addresses access your admin panel.
Framework
A pre-built toolkit that gives you a head start on building your app. Instead of writing everything from scratch, you use a framework that handles common tasks like routing, database access, and security.
Examples: Laravel (PHP), Django (Python), Next.js (JavaScript), Ruby on Rails (Ruby).
Frontend
The part of your app that users see and interact with — buttons, forms, colors, layout. It runs in the user's browser or phone.
Simple way to think about it: The frontend is the restaurant's dining room. The backend is the kitchen.
G
Git
A tool that tracks every change to your code — like "Track Changes" in Google Docs, but for code. It lets you save versions, go back to old versions, and collaborate with others without stepping on each other's toes.
Why it matters: If you break something, you can instantly go back to a working version. If you're working with a team, Git prevents people from overwriting each other's work.
GitHub / GitLab / Bitbucket
Websites that host your Git repositories in the cloud. They also add features like bug tracking, code review, and CI/CD pipelines.
Simple way to think about it: Git is the tool on your computer. GitHub is where you upload your code so others can see it, review it, and contribute.
Git Push
The command that uploads your local code changes to GitHub (or another remote repository). When you "push" your code, you're sending your latest commits to the cloud so others can access them or so your deployment pipeline can pick them up.
Simple way to think about it: You've been working on your app locally. "Pushing" is like publishing your work — sending it from your computer to the shared online repository.
Git Pull
The command that downloads the latest changes from GitHub to your local computer. You "pull" when you want to get the most up-to-date version of the code.
Simple way to think about it: Your teammate pushed their changes. You "pull" to get their updates onto your computer.
GUI (Graphical User Interface)
The visual way to interact with software — buttons, windows, icons, menus. The opposite of a CLI (command line).
Example: The Windows or Mac desktop is a GUI. When you drag a file to the trash, you're using a GUI.
H
HTTPS (Hypertext Transfer Protocol Secure)
The secure version of the web protocol that encrypts data between your user's browser and your server. The little padlock icon in the browser bar means HTTPS is active.
Why it matters: Without HTTPS, anyone on the same Wi-Fi network can read the data being sent between your users and your app — including passwords and credit card numbers.
How to get it: Most modern hosting platforms (Vercel, Netlify, Cloudflare Pages) give you HTTPS for free automatically.
HTTP Request
When a browser asks a server for something — a webpage, an image, some data. Every time you click a link or submit a form, your browser sends an HTTP request.
Example: When you visit https://myapp.com/users, your browser sends an HTTP request asking "give me the users page."
J
JSON (JavaScript Object Notation)
A simple, human-readable format for sending data between apps. It's the most common way APIs exchange information.
Example: A user's data in JSON looks like:
{
"name": "John",
"email": "john@example.com",
"age": 30
}
JWT (JSON Web Token)
A digital ID card that proves a user is who they say they are. When a user logs in, the server creates a JWT and sends it to the browser. The browser sends it back with every request to prove "I'm still logged in."
Simple way to think about it: A JWT is like a stamped wristband at a concert. Once you show your ticket (login), you get the wristband (JWT), and you can flash it to re-enter any area without showing your ticket again.
L
Library
A collection of pre-written code that handles a specific task. Instead of writing everything yourself, you "import" a library and use its features.
Example: Instead of writing code to generate PDFs from scratch, you use a PDF library that already does it.
Linting
An automated tool that checks your code for errors and bad practices. It's like a spell-checker for code — it catches mistakes before they cause problems.
Example: A linter might warn you that you created a variable but never used it, or that your formatting is inconsistent.
M
Merge (Git Merge)
The act of combining changes from one branch into another. When you finish working on a feature in a separate branch, you merge it back into the main branch.
Simple way to think about it: You wrote a new chapter for a book in a separate document. Merging is copying that chapter into the main manuscript.
Middleware
Code that runs between a request and a response — like a checkpoint. It can check if a user is logged in, log the request, or modify the data before it reaches your main code.
Example: Before showing a user's profile, middleware checks "is this user logged in?" If not, it redirects them to the login page.
Migration
See Database Migration above.
N
Node.js
A technology that lets developers run JavaScript on a server instead of just in a browser. It's one of the most popular backend technologies, especially for AI-built apps.
Why you'll hear about it: Many AI coding tools default to Node.js because it's widely used and well-supported.
O
Open Source
Software whose code is publicly available for anyone to view, modify, and distribute. It's usually free to use, but you may need to follow certain rules about attribution.
Examples: Linux, WordPress, VS Code, most AI models (LLaMA, Mistral).
Why it matters: Open-source software is maintained by communities, not single companies. It's generally more transparent and auditable.
ORM (Object-Relational Mapping)
A tool that lets your app talk to a database without writing raw SQL. Instead of writing database queries, you use regular code functions.
Example: Instead of writing SELECT * FROM users WHERE id = 1, you write User.findById(1). The ORM translates your code into database commands.
P
Package Manager
A tool that downloads and manages code libraries for your project. Instead of manually downloading files, you type a command and the package manager handles everything.
Examples: npm (JavaScript), pip (Python), Composer (PHP), gem (Ruby).
Production
The live version of your app that real users access. This is the final, public-facing environment.
See also: Environment (Dev / Staging / Production) above.
Pull Request (PR)
A request to merge your changes into the main codebase. It's a way to say "I've finished this feature, please review my code and merge it in."
Simple way to think about it: You wrote a new section for a group document. A pull request is you saying "Hey team, here's my draft. Can someone review it before I add it to the final document?"
R
Rate Limiting
A safety mechanism that limits how many requests a user or app can make in a given time period. It prevents abuse and protects your server from being overwhelmed.
Example: Your login endpoint might allow 5 attempts per minute. After that, the user has to wait. This prevents bots from trying millions of passwords.
Repository (Repo)
A folder that contains all your code and its version history. It's the central place where your project lives, usually hosted on GitHub.
Example: Your app's repo contains all the code files, configuration, documentation, and the complete history of every change ever made.
REST API
A set of rules for how apps talk to each other over the internet. Most modern web APIs follow REST principles, which use standard HTTP methods (GET, POST, PUT, DELETE) to perform CRUD operations.
Example:
GET /api/users— Fetch all usersPOST /api/users— Create a new userDELETE /api/users/1— Delete user with ID 1
Root Domain
The base version of your domain without any subdomain. It's the main address you own.
Example: In app.mybusiness.com, the root domain is mybusiness.com. The app. part is a subdomain.
Route
A URL pattern that maps to specific code in your app. When a user visits a URL, the router decides which code to run.
Example: The route /products/123 might run code that fetches product #123 from the database and displays it.
S
SaaS (Software as a Service)
An app that you pay to use over the internet instead of installing on your computer. Most modern business software is SaaS.
Examples: Google Docs, Slack, Notion, Figma, Shopify.
Schema
The structure or blueprint of your database — what tables exist, what columns they have, what types of data they store.
Example: A user schema might say: each user has an ID (number), a name (text), an email (text), and a signup date (date).
Server
A computer that runs 24/7 and serves your app to the internet. When someone visits your website, their browser connects to your server, which sends back the website files.
Simple way to think about it: Your laptop is a computer you turn off at night. A server is a computer that never sleeps, always ready to respond to visitors.
Serverless
A way to run your app without managing your own servers. You just upload your code, and the cloud provider runs it on demand. You pay only when your code actually runs.
Examples: Cloudflare Workers, AWS Lambda, Vercel Functions.
Simple way to think about it: Instead of renting an apartment (a server) and paying rent even when you're on vacation, serverless is like staying in a hotel — you only pay for the nights you actually sleep there.
SMTP (Simple Mail Transfer Protocol)
The standard protocol for sending emails over the internet. When your app needs to send an email (welcome email, password reset, notification), it uses an SMTP server.
Simple way to think about it: SMTP is the postal service of the internet. Your app hands the email to an SMTP server, and the server delivers it to the recipient.
Services that handle SMTP for you: SendGrid, Mailgun, Amazon SES, Resend.
SQL (Structured Query Language)
The language used to talk to databases. It's how you ask a database to store, retrieve, update, or delete data.
Example: SELECT * FROM users WHERE email = 'john@example.com' — "Find the user with this email address."
Why you'll hear about it: Even if you never write SQL yourself, your AI coding tool will. Understanding basic SQL helps you spot when your app is doing something dangerous with data.
SSL / TLS Certificate
A digital certificate that enables HTTPS on your website. It encrypts data between your server and your users' browsers.
Simple way to think about it: It's the digital equivalent of a tamper-proof seal on a medicine bottle. Users can verify that the data they're receiving actually came from your server and wasn't tampered with.
Good news: Most modern hosting platforms provide SSL certificates for free. You rarely need to buy one anymore.
Subdomain
A prefix added to your domain to organize different parts of your website. It's like having separate entrances to the same building.
Example: blog.myapp.com (blog), shop.myapp.com (store), admin.myapp.com (admin panel). All are subdomains of myapp.com.
T
Token
A temporary digital key that proves a user is authenticated. When you log into an app, the server gives you a token. Your browser sends this token with every request to prove "I'm still logged in."
See also: JWT above.
U
URL (Uniform Resource Locator)
The full web address of a specific page or resource on the internet. It includes the protocol, domain, and path.
Example: https://myapp.com/products/123 — the protocol is https, the domain is myapp.com, and the path is /products/123.
V
Version Control
A system that tracks every change to your code over time. It lets you see who changed what, when, and why — and go back to any previous version if something breaks.
Examples: Git (the most popular), SVN, Mercurial.
Why it matters: Without version control, you're one accidental delete away from losing everything. With it, you can experiment freely because you can always undo.
W
Webhook
An automatic message that one app sends to another when something happens. Instead of one app constantly asking "anything new?" (polling), the webhook says "hey, something just happened!" (push notification).
Example: When a customer pays on Stripe, Stripe sends a webhook to your app saying "payment received for order #123." Your app then updates the order status and sends a confirmation email.
Simple way to think about it: Instead of calling the restaurant every 5 minutes asking "is my table ready?", you give them your number and they call you when the table is available. That's a webhook.
Whitespace
Spaces, tabs, and blank lines in your code. Some programming languages are very sensitive to whitespace — using the wrong amount can break your app.
Why you'll hear about it: AI coding tools sometimes generate inconsistent whitespace, which can cause mysterious errors. If your app suddenly breaks for no apparent reason, check the whitespace.
Y
YAML
A human-readable format for configuration files. It's used for things like CI/CD pipelines, Docker configurations, and app settings.
Example: A simple YAML file might look like:
app_name: My App
version: 1.0
database:
host: localhost
port: 5432
Why you'll hear about it: Many deployment platforms (Cloudflare Pages, GitHub Actions) use YAML files for configuration. AI tools often generate these files for you.
Quick Reference: Terms by Category
Infrastructure & Hosting
| Term | Plain English |
|---|---|
| Server | A computer that never sleeps, running your app 24/7 |
| Cloud | Someone else's computer you rent over the internet |
| CDN | A network that makes your site load faster worldwide |
| DNS | The phonebook that translates domain names to IP addresses |
| Domain | Your website's address (like myapp.com) |
| Subdomain | A prefix on your domain (like blog.myapp.com) |
| HTTPS | The secure padlock that encrypts data between users and your app |
| SSL/TLS | The digital certificate that enables HTTPS |
| Serverless | Running code without managing servers — pay only when it runs |
Version Control & Collaboration
| Term | Plain English |
|---|---|
| Git | A tool that tracks every change to your code |
| Git Push | Uploading your code changes to GitHub |
| Git Pull | Downloading the latest code changes from GitHub |
| Commit | A saved snapshot of your code at a point in time |
| Branch | A separate copy of your code for experimenting |
| Merge | Combining changes from one branch into another |
| Pull Request (PR) | A request to review and merge your changes |
| Repository (Repo) | The folder where all your code lives |
Security
| Term | Plain English |
|---|---|
| API Key | A secret password that lets apps talk to each other |
| Authentication | Verifying who someone is (login) |
| Authorization | What someone is allowed to do after logging in |
| Firewall | A security guard for your server |
| Rate Limiting | Limiting how many requests someone can make |
| CORS | A browser security rule that prevents data theft |
| JWT / Token | A digital ID card that proves a user is logged in |
Data & Storage
| Term | Plain English |
|---|---|
| Database | A structured place to store your app's data |
| SQL | The language used to talk to databases |
| Schema | The blueprint of your database structure |
| Migration | Safely changing your database without losing data |
| CRUD | Create, Read, Update, Delete — the four basic data operations |
| Cache | Storing copies of data for faster loading |
| JSON | A simple format for sending data between apps |
Deployment & Operations
| Term | Plain English |
|---|---|
| Production | The live version of your app that real users see |
| CI/CD | Automated pipeline that tests and deploys your code |
| Environment | Dev (building), Staging (testing), Production (live) |
| Environment Variables | Settings that live outside your code (API keys, passwords) |
| Build | Converting your code into something a browser can run |
| Docker / Container | A standardized package with everything your app needs |
Communication Between Apps
| Term | Plain English |
|---|---|
| API | A digital waiter that carries messages between apps |
| Endpoint | A specific URL where your API can be reached |
| REST API | A set of rules for how apps talk to each other |
| Webhook | An automatic notification when something happens |
| SMTP | The postal service that delivers emails from your app |
| HTTP Request | When a browser asks a server for something |
Tools & Concepts
| Term | Plain English |
|---|---|
| Framework | A pre-built toolkit to speed up development |
| Library | Pre-written code that handles a specific task |
| Package Manager | A tool that downloads and manages code libraries |
| ORM | A tool that lets your code talk to databases easily |
| CLI | Text-based control of your computer (typing commands) |
| GUI | Visual interface (buttons, windows, icons) |
| Open Source | Code that's publicly available for anyone to use |
| SaaS | An app you pay to use over the internet |
| Node.js | Running JavaScript on a server |
| YAML | A format for configuration files |
| Linting | An automated spell-checker for code |
| Middleware | Code that runs as a checkpoint between requests |
| Route | A URL pattern that maps to specific code |
| CMS | A tool to manage website content without coding |
Still Confused?
That's completely normal. Developers spend years learning this stuff, and even they look things up constantly.
Here's what we recommend:
- Bookmark this page — come back whenever you hit a term you don't recognize
- Ask your AI tool — literally type "explain [term] like I'm a business owner" into ChatGPT or Claude
- Don't try to learn everything at once — most people only need 10-15 terms to get started
- Use the Quick Reference tables above — they're designed for fast scanning when you're in a hurry
The goal isn't to become a developer. The goal is to understand enough to make good decisions, ask the right questions, and avoid costly mistakes.