For designers who want to understand the web

Your design lives here.
The web makes it real.

A visual guide to HTML, CSS, JavaScript, JSON, and how the frontend talks to the backend — no coding experience needed.

Start exploring ↓

A website is like a house

Every website is made of the same parts, just like every house. Once you see the analogy, it all clicks.

🏗️
HTML
The Structure
Walls, floors, rooms, doors. HTML decides what exists on the page and where it goes.
🎨
CSS
The Style
Paint, furniture, lighting. CSS is everything visual — colors, fonts, spacing, layout.
JavaScript
The Behavior
Electricity, smart home. JS makes things move, respond, and feel alive when you interact.
📦
JSON
The Inventory
The list of every piece of furniture. JSON is how data travels from a database to your product cards.
🏭
Backend
The Factory
Where everything is made and stored. Invisible to visitors, but it powers everything you see.

HTML is your wireframe, brought to life

As a designer, you already think in structure — headers, sections, cards, buttons. HTML is just the language that tells the browser what those things are.

Tags describe meaning

HTML uses tags — labels that tell the browser "this is a heading", "this is an image", "this is a button". The browser then knows how to display it.

💡 Think of HTML tags like layer names in Figma. <h1> is your "Heading" layer. <button> is your "CTA Button" layer. <img> is your "Hero Image" layer. Same idea — just in a language the browser understands.
⚠️ HTML alone has no style. It's intentionally plain — just raw structure. That's not a bug, that's the point. The beauty comes next, with CSS.
HTML
<h1>Welcome to my shop</h1>

<p>Free shipping on orders over $50</p>

<button>Shop now</button>

<img src="hero.jpg" alt="Summer collection">
What the browser shows (unstyled)

Welcome to my shop

Free shipping on orders over $50

← does nothing yet (needs JS)
📷 hero.jpg

<img> marks where the image goes — the browser loads it from the src file

CSS is your design system, turned into rules

CSS connects visual rules to HTML elements. Instead of styling each element one by one, you write rules once — and they apply everywhere, automatically.

💡 Think of CSS as your brand guidelines document. "All headings are coral, 32px, DM Serif." Write it once. Every heading on every page follows the rule.

The big lesson: where you write CSS matters a lot

There are three places you can put CSS. One is much better than the others. Your developer will love you for knowing this.

HTML (inline styles)
<h1 style="color:coral; font-size:32px">
  Summer Sale
</h1>

<h1 style="color:coral; font-size:32px">
  New Arrivals
</h1>

<h1 style="color:coral; font-size:32px">
  About Us
</h1>
😬 The problem with this

Now imagine the client changes their mind and wants the headings to be teal instead of coral.

You have to find and update every single heading individually. If you have 50 pages with 10 headings each... that's 500 edits.

This is also why developers quietly sigh when they see inline styles.

HTML (with <style> tag)
<!-- At the top of this one page -->
<style>
  h1 {
    color: coral;
    font-size: 32px;
  }
</style>

<h1>Summer Sale</h1>
<h1>New Arrivals</h1>
<h1>About Us</h1>
🤔 Better, but still a problem

Now all 3 headings on this page update with one change. Progress!

But if your site has 50 pages, each with its own <style> block, you're back to making 50 edits — one per page.

Also: mixing your structure (HTML) and your style rules (CSS) in one file makes both harder to read and maintain.

index.html (and every other page)
<!-- One line, in every HTML file -->
<link rel="stylesheet" href="style.css">

<h1>Summer Sale</h1>
<h1>New Arrivals</h1>
<h1>About Us</h1>
style.css (one file, shared everywhere)
h1 {
  color: coral;
  font-size: 32px;
}
✅ This is the way

style.css is one file loaded by every page. Change the heading color once → every heading, on every page, updates instantly.

Try it right now:

Summer Sale New Arrivals About Us

Click a color → all three update at once, because they share one CSS rule

JavaScript makes your design come alive

HTML is the structure. CSS is the look. JavaScript adds the "when I click this, that happens." It's the difference between a static mockup and a product people actually use.

What JS actually does

  • Opens a menu when you click the hamburger icon
  • Shows an error when you submit an empty form
  • Loads more products as you scroll down
  • Animates the cart icon when you add an item
  • Fetches live prices, stock levels, or search results from a server
  • Remembers that you already added something to your cart
💡 In Figma, you create interactions and prototypes to simulate behavior. JavaScript is how those interactions become real — not simulated, actually working.
📁 JS also lives in its own file. Just like CSS, JavaScript belongs in a separate .js file, linked at the bottom of your HTML. Same reason: one file, one change, everywhere updated.
Interactive demo

This page is using JavaScript right now. The button below would do nothing without it.

What JS runs when you click
cartCount++
cartBtn.textContent = `In cart (${cartCount}) 🛒`
output.textContent = `✅ Added! You have ${cartCount} item(s)`

JSON is how data travels

Every product card, news article, or user profile you design — that content doesn't get written into HTML manually. It lives in a database, travels as JSON, and JavaScript turns it into the cards you designed.

🗃️
Database
Stores all products
📦
JSON
Packages data for travel
JavaScript
Reads the JSON
🎴
Your card design
Filled with real data
JSON arriving from the server
{
  "name": "Linen Tote Bag",
  "price": 42,
  "image": "linen-tote.jpg",
  "inStock": true,
  "colors": [
    "Sand",
    "Sage",
    "Cream"
  ]
}

Structured text. Like a tiny spreadsheet, in a format every language can read.

The product card it becomes
👜
Linen Tote Bag
$42
✓ In stock
This is why designers don't hard-code content into HTML. A shop with 500 products doesn't have 500 HTML files. It has one template (your card design), and JavaScript fills it with data from JSON. You design the template. The data takes care of itself.

The restaurant you never see the kitchen of

Every website has two sides. You live and work in the front-of-house. There's a whole kitchen behind the scenes that makes the experience possible.

🍽️

Frontend

What the customer experiences

  • HTML, CSS, JavaScript
  • Runs inside the browser
  • Anyone can open DevTools and inspect it
  • This is where your design lives
  • Response time feels instant
The wall
👨‍🍳

Backend

What runs the operation

  • Server, database, business logic
  • Runs on a remote computer (not the browser)
  • Hidden from visitors — secure
  • Stores passwords, orders, inventory
  • Sends data back as JSON

How they talk: JavaScript is the waiter

The frontend can't access the database directly. JavaScript sends a request to the backend (like a waiter taking an order to the kitchen), and the backend sends back a response (the dish comes out).

🖥️
Your Browser
Frontend
GET /api/products
🏭
Server
Backend
SELECT * FROM products
🗃️
Database
SQL

The database is just a very organized spreadsheet

A database stores all the content your designs will display — products, users, orders, blog posts. SQL is the language you use to ask for data from it.

Tables look exactly like spreadsheets

A database table has rows and columns, just like a spreadsheet. Each row is one item (one product, one user). Each column is one property (name, price, image).

id name price in_stock
1 Linen Tote Bag 42 true
2 Canvas Tote 38 true
3 Leather Clutch 95 false

SQL is how you ask questions

When your product page needs to show only in-stock items, the backend runs a SQL query like this:

SQL query
SELECT name, price
FROM products
WHERE in_stock = true
ORDER BY price ASC
💡 That query reads almost like plain English: "Give me the name and price of all products where in_stock is true, sorted by price."

The backend runs that query, gets back rows, converts them to JSON, and sends them to your JavaScript — which fills your product card template.

When your developer says...

Now that you know the pieces, here's how to translate dev-speak into designer-speak.

"Let me wire up the component"
They're writing JavaScript to make your designed UI actually do something — respond to clicks, animate, show/hide things.
"We're fetching from the API"
JavaScript is asking the backend for data (product listings, user info, etc.), which will come back as JSON and fill your templates.
"That's a database field"
The content you're designing around (product name, price, image URL) will come from the database, not be typed in by hand.
"We need a migration"
The database structure needs to change — like adding a new column for something you added to your design (e.g., a "badge text" field).
"That's a frontend-only change"
Only HTML/CSS/JS needs updating — no backend or database work. Usually fast to implement. Good news when you hear it.
"I need to update the endpoint"
The specific URL the frontend calls to get/send data needs to change. Think of it like updating which shelf in the kitchen the waiter goes to.
"That's a backend change"
The server or database logic needs updating. Takes longer than a CSS tweak. Worth knowing so timelines make sense.
"The design doesn't reflect the data model"
Your design shows something (like "tags" or "variants") that doesn't exist as a field in the database yet. A conversation worth having early.