Web Development · Beginner Vocabulary

Web Development Terminology Every Beginner Should Learn

SECTION 01Frontend terminology

Everything the user sees and interacts with in the browser.

• Frontend: The part of a website that runs in the browser. It includes layout, styling, and interactivity.
• HTML (HyperText Markup Language): The structure of a web page — headings, paragraphs, links, images.
• CSS (Cascading Style Sheets): Controls how HTML looks — colours, fonts, spacing, layout.
• JavaScript: The programming language that makes pages interactive — clicks, forms, animations, data fetching.
• DOM (Document Object Model): The browser's representation of your HTML. JavaScript manipulates the DOM to change the page.
• Responsive design: Making a site work well on phones, tablets, and desktops using flexible layouts and media queries.
• Framework: A pre-built structure for building apps faster — React, Vue, Angular for frontend.
• Library: A collection of reusable code you call when needed — React is technically a library, not a full framework.
• SPA (Single Page Application): An app that loads once and updates content without full page reloads — e.g., Gmail.
• PWA (Progressive Web App): A web app that behaves like a native app — offline support, installable, push notifications.
• Bundle: The combined, optimised files your build tool produces for the browser — usually one JS file and one CSS file.
• Build tool: Software that compiles, bundles, and optimises your code — e.g., Vite, Webpack, Parcel.
• Transpiler: A tool that converts modern JavaScript or TypeScript into browser-compatible JavaScript — e.g., Babel.

SECTION 02Backend terminology

The part users do not see — servers, databases, and business logic.

• Backend: The server-side of a website — handles logic, data storage, authentication, and APIs.
• Server: A computer or program that responds to requests from clients (browsers, apps).
• Client-server model: The architecture where the client (browser) requests and the server responds.
• Database: Where data is stored and retrieved — SQL (PostgreSQL, MySQL) or NoSQL (MongoDB, Redis).
• API (Application Programming Interface): A defined way for two systems to talk. Backends expose APIs; frontends consume them.
• REST (Representational State Transfer): A common API style using HTTP methods (GET, POST, PUT, DELETE) and URLs.
• GraphQL: An alternative API style where clients request exactly the data they need, avoiding over-fetching.
• Endpoint: A specific URL in an API — e.g., /api/users/42.
• Authentication: Verifying who a user is — login with password, OAuth, or tokens.
• Authorisation: What a logged-in user is allowed to do — permissions, roles, access control.
• Session: Server-side storage of a user's login state. The browser holds a session ID cookie.
• JWT (JSON Web Token): A signed token used for stateless authentication — common in APIs.
• ORM (Object-Relational Mapper): A library that lets you query databases using code instead of raw SQL — e.g., Prisma, SQLAlchemy.
• Middleware: Code that runs between the request and the response — logging, authentication, error handling.

SECTION 03Networking and hosting terms

How the internet actually delivers your website to a user.

• HTTP (HyperText Transfer Protocol): The protocol browsers and servers use to exchange web content.
• HTTPS: HTTP with encryption — the "S" stands for Secure. Modern sites must use HTTPS.
• HTTP methods: GET (fetch), POST (create), PUT (replace), PATCH (update), DELETE (remove).
• Status codes: 200 (OK), 301 (moved), 404 (not found), 500 (server error), 401 (unauthorised).
• Request headers: Metadata sent with each request — content type, authentication token, language.
• DNS (Domain Name System): Converts a domain name like uncodemy.com into an IP address.
• Domain name: The human-readable address of a website — e.g., example.com.
• IP address: The numeric address of a machine — e.g., 142.250.192.14.
• Hosting: A service that stores your website files and serves them to users — e.g., Vercel, Netlify, AWS.
• SSL/TLS certificate: The encryption certificate that makes HTTPS possible.
• CDN (Content Delivery Network): A network of servers that cache assets closer to users for faster loading.
• Latency: The delay between a request and a response. Lower is better.
• CORS (Cross-Origin Resource Sharing): The browser security rule that controls which origins can call your API.
• Cookie: A small piece of data stored in the browser and sent with requests — used for sessions, preferences.

SECTION 04Tools and workflow terms

The tools you use every day as a developer.

• Git: A version control system that tracks changes to your code over time.
• GitHub / GitLab / Bitbucket: Platforms that host Git repositories and support collaboration.
• Repository (repo): A project folder tracked by Git — code, history, and branches.
• Commit: A saved snapshot of your code changes with a message.
• Branch: An independent line of development — used for features, fixes, and experiments.
• Merge: Combining changes from one branch into another.
• Pull request (PR): A proposal to merge your branch — used for code review.
• Clone: Copying a remote repository to your local machine.
• Fork: A personal copy of someone else's repository — common in open source.
• Merge conflict: When Git cannot automatically combine changes and needs manual resolution.
• CI/CD: Continuous Integration / Continuous Deployment — automated testing and deployment pipelines.
• Deployment: Publishing your app so it is available online — to Vercel, Netlify, AWS, etc.
• Environment variables: Configuration values stored outside your code — API keys, database URLs.
• .gitignore: A file listing what Git should not track — node_modules, .env, build folders.
• Package manager: A tool that installs and manages dependencies — npm, yarn, pnpm for JavaScript.
• Dependency: An external package your project needs — listed in package.json.

SECTION 05Architecture and design terms

Higher-level concepts that describe how applications are structured.

• Client-server architecture: The classic model where a client requests and a server responds.
• MVC (Model-View-Controller): A pattern that separates data (model), UI (view), and logic (controller).
• Monolith: A single application containing all features — simpler to start, harder to scale.
• Microservices: Splitting an app into small, independent services — more complex, more scalable.
• Serverless: Running backend code without managing servers — e.g., AWS Lambda, Vercel Functions.
• Static site: A site with pre-built HTML files — fast, simple, and cheap to host.
• SSR (Server-Side Rendering): Rendering HTML on the server for faster first paint and better SEO.
• CSR (Client-Side Rendering): Rendering everything in the browser with JavaScript — common in React SPAs.
• SSG (Static Site Generation): Pre-rendering pages at build time — used by Next.js, Astro.
• Hydration: Attaching JavaScript behaviour to server-rendered HTML in the browser.
• Lazy loading: Loading resources only when needed — images, routes, components.
• Tree shaking: Removing unused code from your final bundle during build.
• Code splitting: Breaking your bundle into smaller chunks so pages load faster.
• Accessibility (a11y): Making websites usable by everyone, including people with disabilities.

SECTION 06How to actually remember these

Vocabulary without context fades in a week. Here is how to make it stick.

• Build something small: A to-do app that uses HTML, CSS, JavaScript, and localStorage teaches 10 terms at once.
• Read error messages carefully: "404", "CORS", "undefined is not a function" — each is a term with a meaning.
• Use DevTools: The Network tab shows HTTP requests and status codes in real time.
• Keep a personal glossary: Write each new term in your own words. If you cannot explain it simply, you do not understand it.
• Watch a deployment happen: Push code to GitHub, connect to Vercel, and see DNS, HTTPS, and CDN working together.
• Explain terms to someone else: Teaching is the fastest way to solidify vocabulary.
• Revisit weekly: Spend 10 minutes every Sunday re-reading your glossary.

SECTION 07Your first 30 days learning plan

A realistic plan to go from zero vocabulary to comfortable with the basics.

• Days 1–7: Learn HTML structure and CSS styling. Terms: elements, attributes, selectors, box model, flexbox.
• Days 8–14: Learn JavaScript basics. Terms: variables, functions, DOM, events, arrays, objects.
• Days 15–21: Learn Git and GitHub. Terms: repo, commit, branch, merge, pull request.
• Days 22–28: Deploy a project. Terms: hosting, DNS, HTTPS, environment variables, build.
• Days 29–30: Review your glossary. Pick one backend tutorial. Terms: server, API, database, endpoint.
• Ongoing: Read one article per week on a new concept. Add the terms to your glossary.
• Avoid: Trying to learn everything at once. Focus on the terms you actually use.

SECTION 08Test yourself — Web dev terminology

SECTION 09Frequently asked questions

SECTION 10Related reads