DEV Community

Cover image for What Is Web Development? A Complete Beginner's Guide
CodeFromScratch
CodeFromScratch

Posted on Originally published at codefromscratch.org

What Is Web Development? A Complete Beginner's Guide

You typed "what is web development" into a search box, and every answer was either a dictionary definition or an advert for a course. Today I'll give you the real map: what web development is, the three languages behind every page, what the browser does and what the server does, how a page reaches your screen, and how to start without drowning. Every piece of code here runs, and some of it you'll click yourself.

Web development, in plain words

Web development is building the things that run in a web browser, and the machines behind them that make those things work. The page you're reading now, your online banking, the form where you book a dentist appointment, the admin screen behind a web shop: someone wrote all of that, and writing it is web development. That's the whole definition. Everything else in this article is detail.

Here's a comparison I'll keep coming back to. A website is a restaurant. The dining room is what you see: the tables, the menu, the look of the place. That's the front end, the part that runs in your browser. The kitchen is where the real work happens, out of sight: the orders, the stock, the recipes. That's the back end, the server. And the waiter who carries your order in and your food out is the connection between the two. We'll meet all three today, and we'll build a tiny version of each.

How to read this. If you're starting from zero, read top to bottom, and don't skip the code, because the code is the point. If you've built a page or two and the part that confuses you is "what does the server actually do", jump to the section where we build one. If you already work as a developer and you're here to send this to someone, the parts marked "for advanced readers" are the bits I'd want a junior to hear from you.

Why this feels so confusing when you start

I wanted to do this since I was about twelve. An older cousin of mine went to a technical school, and watching him was enough to know what I wanted. So I went looking for material, and there's an ocean of it. Videos, courses, roadmaps with two hundred boxes. And almost nobody is direct. Nobody sits you down and says: here's what this is, here's how the pieces connect, here's where you start.

Courses were the worst for this. I finished them and still felt I knew nothing. They taught me to find prime numbers in a loop and pull a name out of an array, and never once showed me where that turns up in a real website. I wrote about that whole problem in why courses leave you feeling like you know nothing, so I won't repeat it here. The short version: you get the pieces, and nobody connects them.

Why does the confusion exist at all? Because the web wasn't designed in one go. It grew. The first web pages, in the early nineties, were documents with links between them. Then people wanted them to look nice, so a language for styling was added. Then they wanted pages that react when you click, so a programming language was put into the browser. Then they wanted logins and shopping carts, so servers and databases got involved. Each layer landed on top of the last one, over thirty years, built by different people solving different problems.

When you learn it the way most tutorials teach it, layer by layer, you get each piece without the reason it exists. That's the confusion. It isn't you. So let's do it the other way round: first the map, then the pieces.

The basics of web development: three languages, two places, one conversation

That's the whole map, and I want you to hold on to it, because every tool you'll ever hear about fits somewhere on it.

  • Three languages. HTML gives a page its structure: this is a heading, this is a paragraph, this is a link. CSS gives it its look: colours, spacing, fonts, where things sit. JavaScript gives it behaviour: what happens when you click, type or scroll.
  • Two places. The browser, on the visitor's phone or laptop, is where the front end runs. The server, a computer somewhere that's always on, is where the back end runs: it keeps the data and decides what the visitor is allowed to do.
  • One conversation. The browser asks for something, the server answers. A request, a response. Every page load, every "add to cart", every login is one of those conversations.

Look, that's all it is. Three languages, two places, one conversation. When a new tool shows up, and one shows up every month, ask which part of the map it belongs to, and it stops being scary. React is a JavaScript tool for the browser. PostgreSQL is a place to keep data, next to the server. Next.js is a tool that works on both sides. Nothing escapes the map.

Now let's build each piece, small enough to understand and real enough to run.

Step 1: HTML, the structure. A website is a folder of files

Here's something that surprised me early on: a website is a file. A few files, in a folder. Your browser opens them the way a music player opens a song. So let's make one. Create a folder called my-site, and inside it a file called index.html. Open it in any text editor and type this in.

my-site/index.html

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Emily's page</title>
    <link rel="stylesheet" href="styles.css" />
  </head>
  <body>
    <h1>Hi, I'm Emily</h1>
    <p>I'm learning web development, one page at a time.</p>
    <a href="https://developer.mozilla.org/">The site I read most</a>
    <script src="script.js"></script>
  </body>
</html>
Enter fullscreen mode Exit fullscreen mode

Every line here does a job, so let's go through them.

  • The first line, doctype html, tells the browser "this is modern HTML, use the current rules". Leave it out and browsers fall back to an old compatibility mode where some CSS behaves strangely. It costs you nothing to keep it.
  • html lang="en" is the root element, the box that holds everything. The lang part tells screen readers how to pronounce the text and tells search engines what language the page is in.
  • head holds information about the page. None of it is drawn on screen. The charset line makes sure letters like é display correctly. The viewport line stops phones from zooming the page out to desktop size. The title is what you see in the browser tab, and what Google shows as the headline of a search result. The link line loads our stylesheet, which we'll write next.
  • body holds what you see. h1 is the main heading; a page should have exactly one. p is a paragraph. a is a link, and href is where it goes.
  • The script line at the bottom loads our JavaScript. It sits at the end on purpose: by the time it runs, the heading and paragraph already exist. We'll see what breaks if you move it.

A word on words. Those things in angle brackets are tags, and a tag with its content is an element. HTML is the bones of every page. If you stripped a beautiful website of all its styling and all its interactivity, what would be left is the HTML, like the framing of a house before the paint and the furniture arrive.

Save the file and double-click it. Your browser opens it and shows a heading, a sentence and a link. It looks plain. That's correct. You've made a website. No, really: that file is a website. Put it on a server and anyone on earth can open it. Everything from here on is making it look better, do more, and talk to other computers.

Step 2: CSS, the look

Now create styles.css in the same folder. A CSS file is a list of rules, and each rule says the same thing: find these elements, and make them look like this.

my-site/styles.css

body {
  font-family: system-ui, sans-serif;
  max-width: 40rem;
  margin: 3rem auto;
  padding: 0 1rem;
  color: #1f2937;
}

h1 {
  color: #0f766e;
}

a {
  color: #0f766e;
  text-decoration: underline;
}
Enter fullscreen mode Exit fullscreen mode
  • body { ... } is a rule. The word before the curly braces is the selector, the thing to find; here it's the body element, so these settings apply to the whole page. Inside the braces are declarations: a property, a colon, a value, a semicolon.
  • font-family: system-ui, sans-serif tells the browser to use the operating system's own font, and if it can't, any font without serifs. Lists like this are fallbacks, read left to right.
  • max-width: 40rem stops lines of text from growing wider than about 640 pixels. A rem is a unit relative to the default text size, which is 16 pixels unless the visitor changed their browser settings, so 40rem is usually 640. Long lines are hard to read; this is the single cheapest thing you can do for readability.
  • margin: 3rem auto puts space above and below the page, and auto on the left and right splits the leftover space evenly, which centres the box. Yes, centring in CSS can be this easy. Not always, but here.
  • padding: 0 1rem keeps the text off the screen edge on a phone. Remove it and your words will touch the glass.
  • The h1 and a rules give the heading and the link a teal colour. The link keeps its underline on purpose: an underline is how people know something is clickable.

What breaks if you delete the link line from the head of index.html? Nothing errors. The page goes back to the browser's defaults: black text, the default serif font, full width. CSS never breaks a page. It just stops dressing it. That's the whole relationship: HTML is the person, CSS is the clothes. Same person, different outfit.

If you want to build a complete page this way, with a proper layout and the box model explained, the HTML and CSS beginner guide walks you through a real one from an empty folder, and flexbox versus grid shows you how to arrange things once you've got more than a few on the page.

Step 3: JavaScript, the behaviour

Now the third file, script.js. HTML and CSS describe a page. JavaScript lets the page do something. Here's the smallest useful example I know: a heading that counts how often you click it.

my-site/script.js

const heading = document.querySelector("h1");
let clicks = 0;

heading.addEventListener("click", () => {
  clicks = clicks + 1;
  heading.textContent = "You clicked me " + clicks + " times";
});
Enter fullscreen mode Exit fullscreen mode
  • document.querySelector("h1") searches the page for the first h1 element and hands it back. We store it in a constant called heading, so we've got a handle on that element, like a remote control for it.
  • let clicks = 0 creates a variable: a named box that holds a value, starting at zero. let means the value can change later. const, on the line above, means it can't.
  • heading.addEventListener("click", ...) says: when a click happens on this heading, run the function that follows. An event is anything that happens on the page: a click, a key press, the page finishing loading. Listening for events is most of what front-end JavaScript does.
  • The part in parentheses with the arrow is the function: a block of code waiting to be run. It adds one to clicks, then replaces the text inside the heading with a new sentence. textContent is the text between the tags, and setting it changes the page immediately.

Reload the page and click the heading. "You clicked me 1 times". Click again: 2. Nothing reloaded. The page changed itself. That's what JavaScript is for, and that's the feeling you're chasing for the first few weeks: a page that reacts.

Yes, "1 times" is bad grammar. Leave it in. It's a good first bug to fix on your own, and the fix is an if statement, which you'll learn in your first week.

Now the promised breakage. Move the script line from the bottom of the body up into the head, reload, and click the heading. Nothing happens. Open the browser's console (press F12) and you'll see an error that every web developer has met: Cannot read properties of null (reading 'addEventListener'). The browser reads your file from top to bottom. In the head, the script ran before the heading existed, so querySelector found nothing and returned null, and you can't add a listener to nothing. Order matters, and now you know why.

All three together, live

Here's a small page you can use right now, inside this article. Type a name and press the button. Click the counter. Then open the HTML, CSS and JavaScript tabs and read the source: it's the same three languages doing the same three jobs as in our folder, just on one page.

Live demo: All three languages on one page. It runs right in the page, so try it in the original article.

A few things in there are worth a closer look, because they come up in every real form you'll ever build.

  • In the HTML, the label has for="name" and the input has id="name". That pairs them: clicking the label focuses the input, and a screen reader announces "Your name" when the input is selected. The button has type="submit", so pressing Enter in the input submits the form too. The counter button has type="button", so it doesn't.
  • The answer paragraph has aria-live="polite". That asks screen readers to read out the greeting when it appears, without interrupting. One attribute, and the page works for people who can't see it.
  • In the CSS, display: flex on the form puts the label, input and button in one row, gap is the space between them, and flex-wrap lets them drop onto a second row on a narrow phone. The rest is colour and padding.
  • In the JavaScript, the form listens for the submit event. The first line inside it, event.preventDefault(), stops the browser from doing its default thing, which is to send the form to a server and reload the page. We've got no server yet, so we handle it ourselves. trim() removes spaces from both ends of what was typed, and if nothing is left, we show a message and stop with return. Otherwise we build the greeting.

Take preventDefault out in your head: the page would reload and the greeting would vanish before you could read it. That one line is the difference between "the page reacts" and "the page restarts". You'll write it in every form you ever make.

One honest note. This demo checks the name in your browser only. In a real app, anything that matters is checked again on the server, because the browser belongs to the visitor, not to you, and anyone can change what it sends. That idea is big enough to get its own article: why you check a login form twice. For now, just remember: the browser is the dining room. You don't let guests into the kitchen.

How a page reaches your screen

Now the conversation. You type codefromscratch.org into the address bar and press Enter. In the half second before the page appears, this happens.

  • Address lookup. Your browser asks the Domain Name System, DNS, for the numeric address of codefromscratch.org. DNS is a phone book: you know the name, it gives you the number. Computers talk to numbers, not names.
  • Connection. The browser opens a connection to that number. With https, the connection is encrypted first, which is what the padlock in the address bar means: nobody between you and the server can read what passes through.
  • Request. The browser sends a short message in a format called HTTP: "GET /blog/what-is-web-development-beginners-guide". GET means "give me", and the path says which page.
  • Response. The server reads the request, maybe asks a database for the article, builds the HTML and sends it back with a status code. 200 means "here you go".
  • Rendering. The browser reads the HTML, notices it references a stylesheet and some scripts, asks for those too, and then draws the page. JavaScript runs, and the page becomes interactive.

Those five steps are the version MDN teaches in How the web works, with a few more details if you want them. Steps one to three are plumbing; you'll learn enough to understand them, and you don't need to become a network engineer. Step four is the back end. Step five is the front end. The whole industry lives in those two.

You can watch two of these steps yourself. Open a terminal, the black window with text, and type this.

terminal

nslookup codefromscratch.org
Enter fullscreen mode Exit fullscreen mode

The answer looks something like "Addresses: 64.29.17.1, 216.198.79.1". Two numbers, because hosting companies answer from more than one machine, and the numbers can change over time. That's step one, done by hand. Now step three and four.

terminal

curl -I https://codefromscratch.org/
Enter fullscreen mode Exit fullscreen mode

output (shortened)

HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Server: Vercel
Enter fullscreen mode Exit fullscreen mode

curl is a tool that sends requests without a browser, and -I asks for the headers only: the envelope, not the letter. The first line is the status, 200 OK. Content-Type tells the browser what kind of thing it's getting, here an HTML page. Server tells you who answered. Try the same command with a page that doesn't exist, like codefromscratch.org/nothing-here, and the first line becomes 404 Not Found. Status codes are the server's one-word answers: 200 fine, 404 no such page, 500 I broke something. You'll meet all three.

When you buy your own domain one day and wonder why it doesn't point at your site yet, that's step one again, and the domain, SSL and DNS guide walks through it.

Step 4: the server, a kitchen you can build in twelve lines

Time for the other side. A server sounds like a big machine in a cold room, and sometimes it is, but the word also means something simpler: a program that waits for requests and answers them. It runs on a computer that's always on. On your laptop it works exactly the same way, except only you can reach it.

We'll write it in JavaScript, which needs one more piece. JavaScript was born inside the browser. Node.js is JavaScript running outside the browser, as an ordinary program on your computer. That's why most beginner paths use it for the server: one language on both sides, nothing new to learn except the server idea itself.

Install it from nodejs.org and take the version marked LTS, which stands for long-term support: the one that gets fixes for years. As I write this, at the end of October 2026, Node 26 has just become the newest LTS line, and the Node team's own advice on that page is that production applications use only LTS releases. The examples here were run on Node 24, the previous LTS, and nothing in them is version-specific.

Now, in a new folder, create server.mjs. The .mjs ending tells Node the file uses the modern import syntax; name it .js and Node still runs it, but prints a warning about guessing.

server.mjs

import { createServer } from "node:http";

const server = createServer((request, response) => {
  if (request.url === "/api/greeting") {
    response.setHeader("Content-Type", "application/json");
    response.end(JSON.stringify({ message: "Hello from the server" }));
    return;
  }
  response.statusCode = 404;
  response.end("Not found");
});

server.listen(4321, () => {
  console.log("Listening on http://localhost:4321");
});
Enter fullscreen mode Exit fullscreen mode
  • import { createServer } from "node:http" pulls in the function we need from a module that ships with Node. Nothing to install. The node: prefix says it's a built-in.
  • createServer takes a function and runs it once for every request that arrives. The function gets two objects: request, which holds what the browser asked for, and response, which we fill in with our answer.
  • if (request.url === "/api/greeting") checks which path was asked for. For that one path, we set a header saying "the body is JSON", write the body with response.end, and return so the code below doesn't run as well.
  • For any other path, we set the status to 404 and answer "Not found". Every server needs an answer for the unexpected; this is yours.
  • server.listen(4321, ...) starts waiting for requests on port 4321. A port is a numbered door on your computer. The browser knocks on door 4321, and this program answers. The function after it runs once, when the door is open, and prints the address.

Start it and ask it something. Two terminals: one to run the server, one to be the browser.

terminal 1

node server.mjs
# Listening on http://localhost:4321
Enter fullscreen mode Exit fullscreen mode

terminal 2

curl -i http://localhost:4321/api/greeting
Enter fullscreen mode Exit fullscreen mode

output

HTTP/1.1 200 OK
Content-Type: application/json

{"message":"Hello from the server"}
Enter fullscreen mode Exit fullscreen mode

localhost means "this computer". The -i flag shows the headers and the body together. And the body is JSON: a text format for data that both sides understand, which looks like a JavaScript object with quotes around the names. It's how the kitchen passes plates to the waiter. Almost every server you'll ever talk to speaks it.

Now the browser side of the same conversation. Three lines.

client.mjs

const response = await fetch("http://localhost:4321/api/greeting");
const data = await response.json();
console.log(data.message);
Enter fullscreen mode Exit fullscreen mode
  • fetch(...) sends a request to that address, the same GET our browser sent earlier. It returns a promise, a placeholder for an answer that isn't here yet, and await pauses this code until the answer arrives. Like ordering and sitting down, instead of standing at the counter frozen.
  • response.json() reads the body and turns the JSON text into a real object. It also takes a moment, so it also gets an await.
  • data.message is the value we put in on the server. Printed, it says "Hello from the server". Same words, other side of the counter.

Run it with node client.mjs while the server is up, and you'll see the greeting. The same three lines work inside a web page, in the browser, as long as the page came from the same server; a page from one site asking another site's server gets blocked by the browser unless that server allows it, a rule called CORS that you'll meet later and curse once.

So that's all it is. A server is a program that answers questions. The browser never walks into the kitchen; it asks the waiter, and a plate comes back. Everything you'll ever build on the back end, logins, carts, dashboards, is this loop with more rules about who may ask for what.

Note: For advanced readers: a real back end is a framework on top of this same idea (Express, Hono, or Next.js route handlers) with a database behind it. The shape never changes: request in, response out. What changes is the part that matters in production: who is allowed to ask (authentication), what they're allowed to get (authorization), how often (rate limits), and what happens when the database is down. Beginners can ignore all of that today. Nobody shipping to real users can.

And the database? It's the storeroom behind the kitchen: the place where accounts, orders and articles live so they survive the server restarting. PostgreSQL is the safe default for most new projects. How you talk to one from JavaScript is a topic of its own, covered in Prisma from zero to production, and the full picture of how every layer of a modern app fits together is in modern full-stack development, explained end to end. Read those later, not now.

Front end, back end, full stack: what the job titles mean

You'll see job adverts for front-end developers, back-end developers and full-stack developers. Now you can translate them.

Front-end developers work in the browser. They care about layout, how a button feels under a thumb on a cheap phone, whether the page works for someone using a screen reader, and whether it loads fast on a bad connection. Back-end developers work on the server. They care about data, correctness and security, and about what happens when ten thousand people press the same button in the same second. Full-stack developers do both to a usable level. Most freelancers and people on small teams end up there out of necessity: when a local shop asks you for a website, it has to work end to end, not just look nice.

You'll also hear names of tools, so here's where they sit on the map. React is a JavaScript library for building the browser side out of reusable pieces called components. Next.js is a framework around React that also runs on the server; this site is built with it. Vue and Svelte do the same job as React with different ideas about how. On the server side, JavaScript with Node is one option. Python, with frameworks like Django or FastAPI, is another. PHP still runs a huge slice of the web through WordPress, which the statistics company W3Techs counted on about 39.5 percent of all websites in October 2026. Go and Ruby are there too. All of them fit the map. None of them need picking today.

Source for the WordPress figure: W3Techs, usage of content management systems. Treat it as a survey, not a law of nature.

Where this blog stands: most of what I write uses JavaScript on both sides, with Next.js, because it's what I work with as a web developer, and because one language first is kinder to a beginner than two. That's a preference, not a verdict. The map is the same in every language.

Tools you'll meet in the first month

You don't need a powerful computer, a paid program or a particular brand of laptop. Here's what shows up on day one and stays with you for the rest of your career.

  • A code editor. VS Code is free and is what most working developers use. It colours your code, points out typos, and has an extension for everything.
  • A browser with developer tools. Chrome, Firefox, Edge or Safari, they all have them. Press F12 (or Cmd+Option+I on a Mac) and a panel opens that lets you inspect any page on earth, see its HTML, change its CSS live, and read the errors your JavaScript throws. You'll live in it.
  • Git and GitHub. Git keeps every version of your files so you can undo anything; GitHub is where you store and share them. Learn the five basic commands in week one. Future you will be grateful.
  • Node.js and npm. Node runs JavaScript outside the browser, as you saw. npm, which comes with it, installs code other people wrote so you don't have to write it yourself.
  • A terminal. The text window. Scary for a week, useful forever. About ten commands cover the first year.

Total cost to start: zero. Any laptop from the last several years is fine.

And then there's AI. You'll be tempted to let an AI tool write all of it, and you'll see people online who build whole apps that way without understanding a line. I use AI tools a lot in my work, and I check what they write as far as I can, because they make mistakes without meaning to, and they assume things they shouldn't. Here's the honest rule: AI is good at typing code and bad at knowing what should be typed. If you don't understand the three languages and the conversation, you can't tell when it's wrong, and it will be wrong, and the first bug you can't read will stop you cold. Learn the map first. Then AI becomes a fast colleague instead of a mystery box, and you become the person who directs it, which is where this job is going.

Beginning web development: what to learn, in what order

I'm not going to give you "become a developer in 30 days". I don't have an honest number, and anyone who gives you one is selling something. What I can give you is the order, because the order is where most people go wrong.

  • First, HTML and CSS, on a page that is yours. About you, your dog, your football team, your favourite recipes. Then find a simple page you like online and rebuild it by hand, without a template. You'll be slow and you won't always know why something works. Repetition is the teacher here.
  • Second, JavaScript, by making your page react. A dark-mode toggle. A counter. A list you can add things to. Expect to relearn functions, events and the difference between an array and an object three or four times before they stick. That is normal. People who are good at this now were confused at this exact point.
  • Third, one real small project, finished. Not five started. Pick something you'd use yourself and take it to done, ugly if necessary. Finishing is a skill, and it's the one that courses never train.
  • Fourth, the conversation. A tiny server like the one above, a form that sends to it, and data that survives a restart. The day a form on your page writes a row into a database is the day it all clicks.
  • Fifth, and only now, a framework such as React or Next.js. People who jump to React in week two get lost, because a framework hides the JavaScript under it and they never learned what's being hidden.
  • Sixth, put something online with a real address and show it to a real person. That's when it stops being an exercise.

When you reach step six, shipping a Next.js app to production covers the whole move from your laptop to a real URL. Bookmark it, don't read it yet.

On pace. You'll read "study two or three hours every day". I think that's bad advice for a beginner. Some days code goes in and some days it doesn't. You get sick, you have moods, life happens. Take a day or two off rather than get sick of the whole thing. But don't take long breaks or frequent ones either, because then no habit forms and you forget what you learned. A little, most days. One percent a day over a year beats a heroic weekend followed by a month off.

And if you're starting late, or starting over: I had to restart my education from the beginning in a new country, in a language I didn't speak yet. It was a detour, and detours are fine. If you love this enough to come back to it on evenings and weekends, you'll get there. That's not advice to overwork, and I'll keep saying so. It's advice to keep going.

Myths, corrected

  • "You need to be good at maths." You need to be good at logical thinking. The maths behind most of the web is adding, multiplying and percentages. Game engines and 3D graphics are the exception, and you're not starting there.
  • "It's too late to start at 30 or 40 or 50." Your previous career is an advantage. People who can talk to clients, write clearly and run a project are rarer in this field than people who can code.
  • "AI will replace developers." AI changes how the work is done, less typing and debugging, more directing and checking. The people who fall behind are the ones who never learn to check. Whoever lags falls behind fast, because AI moves fast. Learn the map and you're ahead of most of the room.
  • "You need to learn everything before you start." You need to learn enough to build one small thing, then the next thing as you build the next small thing. Nobody knows the whole field, and many people working in companies don't know everything and need help every week. That's normal. Not knowing yet is fine.
  • "You need a degree." You need a browser, an editor and the patience to ship things that look bad before they look good. Study if you can, it helps. It isn't the gate.

What to be careful about, and the Plan B

Here's what I'd tell myself at the start, because I got every one of these wrong. For a long time I built things from my head until I liked how they looked. No plan, no sketch, no thought about which tags I was using, whether anyone would ever find the site, or whether the people using it were safe. All of that caught up with me later.

  • Plan before you type. Even a sketch on paper. Decide what the page is for and what's on it, then build. "From my head until it looks good" works right up until it doesn't.
  • Use the right tags, not just div for everything. Screen readers and search engines read your HTML, not your screen. A heading should be an h1, a list a ul, a button a button.
  • Think about being found. The best content on earth is invisible if a search engine never shows it. I didn't think SEO mattered. It does, and it starts with a good title and clean HTML, which you now have.
  • Never trust the browser. Anything that matters, prices, permissions, passwords, is checked on the server. The front end is the dining room; the rules live in the kitchen.
  • Don't just watch. Tutorials you only watch leave nothing behind. Type every example, break it on purpose, fix it.
  • Don't ship what you can't explain. If an AI wrote it and you can't say what each line does, you don't own it yet. Ask it to explain, then check the explanation. I wrote a separate piece on learning web development with AI: what to learn yourself and what to hand off.

And the Plan B for when you're stuck, because you will be. First, read the error message out loud, word by word. It's usually telling the truth, like our null error above. Second, make the smallest possible page that still shows the problem; half the time the bug reveals itself while you shrink it. Third, search the exact text of the error. Fourth, ask someone. Write to me if you like. I mean that. Being stuck for an hour is learning. Being stuck for a week alone is how people quit.

Warning: For advanced readers who mentor beginners: the most useful thing you can give someone is the map above and one real project, not a list of technologies to learn. The list is what made them feel they knew nothing in the first place. And when you review their code, explain why, every time. The why is what they can't get from a tutorial.

So that's all it is

Three languages: HTML for structure, CSS for the look, JavaScript for behaviour. Two places: the browser and the server. One conversation: request, response. You built a page, styled it, made it react, watched a request with your own eyes, and wrote a server that answered one. That's not an introduction to web development. That's web development, small.

What next, in order. Build your first real page with the HTML and CSS beginner guide. When you've got more than a few things to arrange, read flexbox versus grid on real layouts. When your first form is ready, read why you check a login form twice and you'll see the conversation from both sides. Much later, when something of yours has real users, the production-grade code checklist is the list of habits that keep them safe.

You can do this, and you have to. If you weren't capable, I wouldn't spend my time on you. Just don't give up, and you'll always have me on your side.


This article first appeared on CodeFromScratch, where the live demos run right in the page.

Free: The Production Checklist. 24 checks to run before a web app meets real users, each linked to the article that explains it. Get it with the newsletter: one short email when a new article goes live, unsubscribe in one click.

Top comments (0)