What Is the Web? World Wide Web vs Internet and How It Works

The web is so deeply woven into our lives that the concept itself is often confused with the internet. In reality, the web is just a service that runs on top of the internet — and it's only one of hundreds of services the internet offers. This guide tackles the question "what is the web" from scratch, across every technical layer: the birth of the World Wide Web in 1989, how HTTP speaks, how URLs are resolved, the journey a browser takes from request to pixels on screen, and the evolution from Web 1.0 all the way to Web 4.0.

Related guides: What is DNS and how to change settings · What is hosting, hosting types · What is a domain, WHOIS lookup · HTTPS and TLS 1.3 · Search engines and SEO guide · Core Web Vitals 2026

What Does "Web" Mean? The Shortest Definition

Web, taken literally, means "network" or "spider's web." In a computing context, it's short for World Wide Web (WWW). The formal definition: the web is a distributed information system made up of documents and resources published over the internet and linked together by hypertext references. Three keywords in that definition matter: distributed (resources don't live in one central place; they sit across thousands of servers around the world), hypertext (documents are connected by clickable references called "links"), and over the internet (the web isn't the internet itself; it's an application layer that runs on top of it).

An analogy: the internet is a road infrastructure — asphalt, bridges, tunnels, traffic rules. The web is a specific shipping company that drives on those roads. Email (SMTP), file transfer (FTP), remote terminals (SSH), DNS lookups (DNS protocol), voice communication (SIP/RTP), gaming protocols, and dozens of other services share the same roads. The web is just the part that speaks HTTP/HTTPS and renders content inside a browser.

Web vs Internet: The Two Most Commonly Confused Terms

When someone says "I'm going on the internet," what most users actually mean is "I'm opening a site in a web browser." The technically correct phrasing would be I'm connecting to the web. The biggest reason for the confusion is that, over the last 30 years, the web has swallowed every other service: email is now read through web interfaces like Gmail and Outlook, file sharing happens through Google Drive and Dropbox, chat is handled in WhatsApp Web. As a result, for the average user, "internet = web browser."

• Internet: The physical + logical network infrastructure that started as ARPANET in 1969, built on top of the TCP/IP protocol stack. It connects devices to one another.
• Web (WWW): An information-sharing service invented by Tim Berners-Lee in 1989, running on top of the internet, using the HTTP, HTML, and URL trio.
• Age difference: The internet is 20 years older than the web. The internet existed without the web; services like email, FTP, Usenet, IRC, and telnet were already widespread in the 1980s.
• Scope difference: The internet fully contains the web. The web is just one subset of the internet.
• Protocol difference: The internet's foundation is TCP/IP (transport layer). The web's foundation is HTTP (application layer), and it runs on top of TCP/IP.

This distinction isn't an academic detail — it shapes decisions around hosting, network security, and domain purchases. For deeper server concepts see our VPS guide, for the domain side our domain primer, and for DNS function our DNS guide — they're all good starting points.

A Brief History of the World Wide Web (1989–2026)

The web was invented at the CERN (European Organization for Nuclear Research) laboratory in Geneva, Switzerland, by British physicist-engineer Tim Berners-Lee. The proposal he submitted to his manager in March 1989, titled "Information Management: A Proposal," is the birth certificate of the modern web. The goal was to let CERN's thousands of researchers share documents — scattered across different machines — through a single common system.

• 1989: Tim Berners-Lee publishes "Information Management: A Proposal" at CERN. The idea of the web is born.
• 1990: The first web browser ("WorldWideWeb," later renamed "Nexus") and the first web server are developed on a NeXT computer. The first URL: http://info.cern.ch/.
• 1991: The web opens up to its first users outside CERN.
• 1993: CERN releases the web technology into the public domain royalty-free — this decision is the single biggest factor behind the web's explosion. The same year, the NCSA Mosaic browser ships, the first popular browser with a graphical interface.
• 1994: Netscape Navigator launches and the W3C (World Wide Web Consortium) is founded. W3C is still the main body for web standards.
• 1995: JavaScript (Brendan Eich), PHP (Rasmus Lerdorf), and Microsoft Internet Explorer all arrive.
• 1998: Google is founded; the search engine takes the central seat in making the web actually usable.
• 2004: Tim O'Reilly popularizes the term "Web 2.0." Facebook launches.
• 2008: Google Chrome launches; the modern browser race begins.
• 2014: HTML5 officially becomes a W3C Recommendation.
• 2015: HTTP/2 (RFC 7540) is published.
• 2022: HTTP/3 (RFC 9114) is standardized over QUIC.
• 2026: The web is over 30 years old; an estimated 5 billion+ active users and over 1.1 billion registered domain names.

The source code of the very first web page is still accessible: you can view the original 1991 page at info.cern.ch. CERN brought this URL back online in 2013 because of its historical significance.

The Three Pillars of the Web: HTTP, HTML, and URL

To say Tim Berners-Lee "invented" the web is really to say he made three separate inventions at the same time. Without any one of them the web doesn't work; each one needs the other two. Below we'll examine each in turn.

1. HTTP — The Conversation Language

HTTP (HyperText Transfer Protocol) is the language spoken between the browser (client) and the web server. Think of it as an "order protocol" — the client says "give me this page" and the server responds. HTTP is stateless; by default the server doesn't remember that two consecutive requests came from the same user (cookie and token mechanisms were developed for session management).

HTTP has gone through several versions over the years. Each one fixed shortcomings of the previous version:

• HTTP/0.9 (1991): GET only, HTML responses only. A one-line protocol.
• HTTP/1.0 (1996, RFC 1945): Headers, status codes, and different MIME types added.
• HTTP/1.1 (1997, RFC 2616): Persistent connections (keep-alive), virtual hosts (Host header), pipelining.
• HTTP/2 (2015, RFC 7540): Binary framing, multiplexing (parallel requests on one connection), header compression (HPACK), server push.
• HTTP/3 (2022, RFC 9114): QUIC (over UDP) instead of TCP — no head-of-line blocking, faster handshake, better mobile performance.

The secure version of HTTP is HTTPS. HTTPS isn't actually a separate protocol; it's HTTP running underneath the TLS (Transport Layer Security) encryption layer. We cover the details thoroughly in our HTTPS and TLS 1.3 guide.

2. HTML — Document Structure

HTML (HyperText Markup Language) is the markup language that forms the skeleton of a web page. It's not a programming language; it's a tag system designed to mark up content with structural meaning (heading, paragraph, link, image, table, form). The browser reads these tags and renders them visually.

The latest major version of HTML is HTML5 (which became a W3C Recommendation in 2014). Since HTML5, the standard has been maintained by WHATWG (Web Hypertext Application Technology Working Group) as a "living standard" — there's no longer any expectation of an "HTML6" version number. You can find the current HTML standard at html.spec.whatwg.org.

3. URL — The Addressing System

A URL (Uniform Resource Locator) is the unique address of a resource on the web. It sits inside the broader concept of URI (Uniform Resource Identifier). The structure of a modern URL looks like this:

The URL standard is now defined by the WHATWG URL Living Standard (url.spec.whatwg.org). It maintains compatibility with the older RFC 3986 but stays closer to actual browser behavior. URLs containing non-ASCII characters, emojis, or spaces are handled with punycode (ASCII conversion) and percent encoding (escapes like %20).

The Journey of a Request: From Browser to Server, Step by Step

What happens behind the curtain when you type https://www.example.com into the address bar and press Enter? The technical name for this process is "navigation," and it's made up of dozens of sub-steps. Let's walk through the most important ones.

• 1. URL parse: The browser splits the address into scheme + host + path + query.
• 2. HSTS check: The browser first looks at its "is HTTPS mandatory for this domain?" list. If it's mandatory, even a typed http:// is immediately upgraded to https://.
• 3. DNS lookup: www.example.com is resolved to an IP address. First the browser DNS cache is checked, then the OS resolver, then the ISP's recursive DNS server, then root → TLD → authoritative DNS servers.
• 4. TCP handshake: The browser performs the three-way handshake (SYN, SYN-ACK, ACK) to port 443 on that IP.
• 5. TLS handshake: Certificate validation, key exchange, and establishment of the encrypted channel. With TLS 1.3 this drops to 1-RTT (or even 0-RTT).
• 6. HTTP request: GET / HTTP/2 + headers are sent.
• 7. Server processing: Reverse proxy → application server → database → response generation.
• 8. HTTP response: Status code (200/301/404/500), headers, body (HTML).
• 9. HTML parse: The browser tokenizes the HTML and builds the DOM tree.
• 10. Sub-resources: Additional HTTP requests for CSS, JS, images, and fonts (modern HTTP/2 multiplexing sends these in parallel over a single connection).
• 11. CSSOM + Render Tree: CSS is parsed into the CSSOM; combined with the DOM it produces the render tree.
• 12. Layout: The browser calculates the position and size of every element on the screen.
• 13. Paint + Composite: Pixels are sent to the GPU and the screen is drawn.
• 14. JavaScript execution: defer/async scripts are parsed, compiled, and executed by V8/SpiderMonkey/JavaScriptCore.
• 15. Interactive: The user can finally click and get a response.

Every link in this chain can be optimized at the millisecond scale. The metrics that measure the total time — TTFB, FCP, LCP, INP, CLS — form the foundation of modern web performance. For details see our Core Web Vitals 2026 article and our site optimization guide.

Client-Server Architecture

All the logic of the web rests on the client-server model. The client requests a resource from the server; the server processes the request and returns a response. This classic model differs from peer-to-peer (P2P), where every node plays both client and server roles.

• Client side: Browsers (Chrome, Firefox, Safari, Edge), mobile app webviews, headless browsers (Playwright, Puppeteer), CLI clients (curl, wget, httpie).
• Server side: Web server software (Nginx, Apache, Caddy, LiteSpeed, IIS), application servers (Node.js, PHP-FPM, Gunicorn, Tomcat), databases (MySQL, PostgreSQL, MongoDB), cache layers (Redis, Memcached, Varnish).
• Intermediate layers: CDNs (Cloudflare, Bunny, Fastly), reverse proxies, load balancers, WAFs, API gateways.

In modern web architecture, the "server" isn't a single machine but a horizontally scaled cluster. When an e-commerce site loads, it might be hitting 10–30 different microservices: product service, pricing service, inventory service, cart, user, payment, shipping, recommendation engine, and so on. For details see our Nginx configuration and Kubernetes basics articles.

Web Page, Web Site, and Web Application

These three terms are often used interchangeably, but technically they're different layers.

• Web page: A single HTML document displayed in the browser. Specific URL, specific content. "/blog/what-is-the-web-www-internet-guide" is a single page.
• Web site: A collection of multiple web pages grouped under the same domain (and usually the same theme/design). A blog, a corporate site, a portfolio — all of these are web sites.
• Web application: Unlike a static site that just displays information, a web application is a dynamic, stateful system that processes user data and typically has sign-in/sign-out functionality. Gmail, Google Docs, Trello, and online banking are example applications.
• SaaS (Software as a Service): The commercial form of a web application — a multi-tenant service accessed via subscription fee. Slack, Notion, Figma, Salesforce.
• PWA (Progressive Web App): Modern web applications that run in the browser yet deliver a near-native experience, work offline, and can be added to the home screen.

Setting up a web site requires three core building blocks: a domain name, hosting (a server), and content (HTML/CSS/JS or a CMS). For an e-commerce-focused setup our how to set up an e-commerce site article goes deeper.

Web 1.0, Web 2.0, Web 3.0, Web 4.0: The Evolution

The web isn't a static technology. In 30 years it has gone through four major paradigm shifts. This evolution is most often labeled with the "Web X.0" tags.

Web 1.0 — The Read-Only Web (1991–2004)

The early web was static: HTML documents, a handful of images, almost no interactivity. Users only read; the right to write belonged to a small minority of content producers. Pages were authored by hand in HTML or with editors like FrontPage and Dreamweaver. Typical features: frameset-based design, animated GIFs, visitor counters, average 56 Kbps modem speeds, and personal sites in the GeoCities/Tripod style.

Web 2.0 — The Read-Write Web (2004–2014)

Popularized by Tim O'Reilly's 2004 conference, Web 2.0 marks the era where the user also became a content producer. The key technology is AJAX (talking to the server without reloading the page). Wikipedia, YouTube, Facebook, Twitter, Flickr, blog systems, and RSS feeds are the icons of Web 2.0. Social networks, user comments, forums, tagging, folksonomies, and mashup applications are all products of this era.

Web 3.0 — The Semantic and Decentralized Web (2014–...)

Web 3.0 is referenced under two different definitions. Tim Berners-Lee's original definition was the Semantic Web: a web where machines could associate meaning, serving structured data through RDF/OWL/SPARQL. In recent years the popular usage has shifted toward the decentralized web: blockchain-based dApps, DAOs, NFTs, signing in with crypto wallets (Sign-In With Ethereum), and distributed storage like IPFS. Which definition will win remains to be seen; both currents are evolving on their own terms.

Web 4.0 — The Smart / Symbiotic Web (2020–...)

A concept that hasn't fully settled yet. Most commentators paint Web 4.0 as an era that is integrated with AI, intertwined with IoT, and centered on spatial computing (AR/VR/spatial). In its 2023 strategy paper, the European Commission defined Web 4.0 as "a phase where virtual worlds and the real world merge." With the explosion of generative AI, an era is rapidly taking shape in which AI agents use web content as a tool.

Client-Side Technologies

For a browser to put pixels on the screen, it depends on three core languages: HTML (structure), CSS (appearance), and JavaScript (behavior). Beyond these, the modern web ecosystem includes dozens of supporting technologies.

• HTML: The semantic structure of the document. Meaningful tags like <header>, <nav>, <main>, <article>, <footer>.
• CSS: Style and layout. Modern features like flexbox, CSS Grid, custom properties (variables), container queries, and the :has() selector.
• JavaScript: Standardized as ECMAScript; a new ES version every year. Features like async/await, modules (import), optional chaining (?.), and nullish coalescing (??).
• WebAssembly (Wasm): A binary format compiled from languages like C++/Rust/Go that runs at near-native speed in the browser. Figma's design engine, AutoCAD Web, and game engines all use Wasm.
• Web Components: Framework-agnostic components built from Custom Elements + Shadow DOM + HTML Templates.
• Service Worker: Offline support, push notifications, background sync.
• WebSocket / WebTransport: Bidirectional real-time communication.
• WebRTC: P2P voice/video calls and screen sharing.
• WebGL / WebGPU: 3D graphics and general-purpose GPU compute.

Modern frontend development is rarely done with "pure HTML+CSS+JS"; most projects pick UI frameworks like React, Vue, or Svelte. For details see our building a modern web app with React, Next.js 15 App Router, Vue 3 Composition API, and Tailwind CSS from scratch articles.

Server-Side Technologies

On the side responsible for sending HTML/JSON/files back to the browser, the spectrum is just as wide. Which language or framework you pick depends on performance requirements, your team's expertise, ecosystem maturity, and cost factors.

• Node.js: A JavaScript runtime on top of the V8 engine. Widely used with frameworks like Express, Fastify, NestJS, and Hono.
• PHP: The most widespread language on the web (75%+ of sites run PHP, mostly WordPress). Laravel, Symfony, and Slim are modern frameworks.
• Python: Django (full-stack, batteries-included), FastAPI (modern async), Flask (micro). A favorite for data/AI-heavy projects.
• Ruby: Ruby on Rails — the standard-setter for developer ergonomics.
• Go: Clean, fast, compiled. A go-to for APIs that demand high concurrency.
• Rust: A modern systems language that guarantees memory safety at compile time and offers zero-cost abstractions. Frameworks include Actix, Axum, and Rocket.
• Java / Kotlin: The Spring Boot ecosystem in the enterprise world.
• C# /.NET: ASP.NET Core for enterprise and game backends.
• Elixir: Real-time applications on the BEAM VM with Phoenix LiveView.

For topics like REST API design, middleware, and authentication, our Node.js REST API development, Express.js middleware pattern, and REST API security guide articles are deep references.

Web Server and Reverse Proxy

The application server (Node.js, PHP-FPM, Gunicorn) is usually not exposed to the internet directly; a web server or reverse proxy is placed in front of it. The reasons: TLS termination, static file serving, compression, caching, rate limiting, load balancing, and security filtering can all be managed from a single point.

• Nginx: High concurrency, low memory footprint. Event-driven architecture. The industry standard for high-traffic sites.
• Apache HTTP Server: The oldest. Modular structure (.htaccess), prefork/worker/event MPMs. A vast ecosystem.
• Caddy: Automatic HTTPS (Let's Encrypt integration), simple configuration. Written in Go.
• LiteSpeed: Server-level cache for WordPress (LSCache). High performance.
• HAProxy: A pure load balancer. Operates at the TCP/HTTP layer; widely used in the enterprise.
• Traefik: A container-native (Docker, Kubernetes) reverse proxy. Automatic service discovery.

For a broader Nginx reference see our Nginx configuration guide, for an Apache comparison Nginx vs Apache, and for LiteSpeed-focused tuning the LSCache guide.

Domains and DNS: The Web's Address Book

Computers talk to each other via IP addresses; humans prefer readable names like www.example.com. The system that performs this translation is DNS (Domain Name System) — the phone book of the internet.

• A: IPv4 address
• AAAA: IPv6 address
• CNAME: Makes one name an alias for another
• MX: Mail server
• TXT: Free-form text (SPF, DKIM, domain verification)
• NS: Who manages the domain (authoritative nameserver)
• SOA: Start-of-authority info for the zone
• CAA: Which CA may issue SSL certificates

The domain system is hierarchical: root → TLD (.com, .tr) → SLD (brandname) → subdomain (www). Turkey's .tr extension was managed by METU's Nic.tr until 2022 (now under TRABİS, controlled by BTK). For details our what is DNS, domain lookup tools, and how to register a.com.tr articles are good starting points.

Hosting: Where Does a Web Site Live?

The internet-connected, 24/7-running computer where a web site's files are stored is called a web server; the service of selling that server is called hosting. Hosting comes in several tiers.

• Shared hosting: Hundreds of customers on the same physical server. Cheapest, most limited.
• VPS (Virtual Private Server): Virtualization splits one server into several "virtual" servers. Root access, your own resources.
• VDS (Virtual Dedicated Server): A virtual server with fixed, non-shared resources (CPU/RAM).
• Dedicated (physical) server: The entire physical machine is yours. Highest performance.
• Cloud hosting: AWS, Azure, GCP, Hetzner, DigitalOcean — elastic scaling, pay-as-you-go.
• Managed hosting: The provider handles server management; you just deploy your code (Vercel, Netlify, Heroku-style PaaS).

Traffic, budget, technical skill, and uptime requirements all weigh into which tier you should pick. For a detailed comparison see our what is hosting, hosting types, VPS vs VDS, cheapest Linux hosting, and site management with cPanel articles. Approximate market prices (2026, varies by provider): shared hosting around $2–6 USD/month, VPS around $6–35 USD/month, dedicated around $60–500 USD/month.

The Web Browser: Your Window to the Web

A web browser is the client software through which a user interacts with the web. The first graphical browser was NCSA Mosaic in 1993. Today four major rendering engines dominate the global market:

• Blink (Chromium-based): Google Chrome, Microsoft Edge, Brave, Opera, Vivaldi, Arc — over 65% of the market.
• Gecko: Mozilla Firefox — independent, open source, developed by the Mozilla Foundation.
• WebKit: Apple Safari (on iOS, all browsers were legally required to use WebKit; that requirement loosened after the EU DMA).
• Servo: An experimental engine written in Rust; development continues under the Linux Foundation.

A browser's internals are deeply layered: networking stack, HTML parser, CSS parser, JavaScript engine (V8, SpiderMonkey, JavaScriptCore), layout engine, paint, GPU compositor, sandboxing (each tab in its own process). Modern browsers are essentially the size of an operating system on their own — the Chromium codebase is over 30 million lines.

Static vs Dynamic Pages

Web pages fall into two main categories based on how they're produced.

• Static page: An HTML file is prepared in advance and sits on the server as-is. Every request returns the same content. Pros: fast, cheap, fully cacheable on a CDN, secure (minimal attack surface). Examples: a blog post, a documentation page, a landing page.
• Dynamic page: For each request, the server runs the page using the database + business logic. Output varies by user, session, time, or parameters. Pros: personalization, forms, accounts. Cons: more expensive, requires careful caching, large security surface.

In modern web architecture the lines are blurred. Hybrid strategies like SSG (Static Site Generation — Next.js, Astro, Hugo, Jekyll), SSR (Server-Side Rendering — generate HTML per request), ISR (Incremental Static Regeneration — generate statically but refresh at intervals), and CSR (Client-Side Rendering — empty HTML, JS does the rendering) are mixed and matched within the same project.

Web Standards and Governance

The web's greatest strength is that it doesn't belong to any single company. Standards are produced through open processes by non-profit organizations. Because of this, no one — Microsoft, Apple, Google, or Mozilla — can unilaterally change the direction of the web.

• W3C (World Wide Web Consortium): The main producer of standards like HTML, CSS, ARIA, and WAI. Founded by Tim Berners-Lee in 1994.
• WHATWG: Manages the HTML Living Standard, DOM, Fetch, and URL specs. Born in 2004 from a founding by Apple, Mozilla, and Opera.
• IETF (Internet Engineering Task Force): Standardizes core protocols like HTTP, TLS, and DNS through RFC documents.
• ECMA TC39: Manages the ECMAScript (JavaScript) standard. Annual ES2024, ES2025, ES2026 releases.
• IEEE / ISO / ITU: Broader IT standards.
• ICANN: Domain name system and IP address allocation.
• IANA: A sub-body managed by ICANN; protocol port numbers, MIME types, and so on.

Whether a web standard actually lands depends on how quickly browser vendors implement it. You can check which feature is supported in which browser version at caniuse.com; web.dev/baseline offers a more prescriptive reference for features that are "safe to use."

Web Security: Core Concepts

The web's open nature also leaves it open to attack. A modern web site has to apply dozens of layered security controls. The most important ones:

• HTTPS / TLS: Traffic encryption. It works through certificate authorities (CAs) signing certificates. We have a free SSL with Let's Encrypt and how to get an SSL certificate guide.
• SQL Injection: Inserting user input directly into the SQL query text instead of as a parameter. Our prevention guide.
• XSS (Cross-Site Scripting): Attacker injects malicious JS into the page. Solution: input escaping + CSP. CSP guide.
• CSRF (Cross-Site Request Forgery): The user's session is triggered from another site. Solution: SameSite cookies + tokens.
• OWASP Top 10: The industry-standard threat list for web application security. Our OWASP Top 10 2026 article.
• Rate limit + DDoS protection: API rate limiting, DDoS protection.
• JWT security: For common pitfalls in token-based sessions, see our JWT security guide.
• VPS hardening: For controls that should be applied at the server level, see VPS security hardening and fail2ban.

Web and Content: SEO, Accessibility, Performance

A web site being live and a web site being successful aren't the same thing. There are three main quality axes: search engine visibility (SEO), accessibility (a11y), and performance (page speed).

• SEO: Whether Google and other search engines can index your site, understand it, and rank it for the right queries. Search engine guide, technical SEO checklist, local SEO, e-commerce SEO.
• Accessibility (a11y): Making sure users with disabilities can also use your site. The WCAG 2.2 AA standard is prescriptive. Semantic HTML, ARIA, keyboard navigation, contrast ratio, alt text.
• Performance: Core Web Vitals (LCP, INP, CLS) targets. Both UX and SEO ranking are affected. For details see Core Web Vitals 2026 and site optimization.

APIs: The Web Between Servers

Most modern web traffic no longer comes from the browser — it comes from API calls. A mobile app, a frontend SPA, a B2B integration — all of them speak JSON/XML to the server. Three main API styles dominate.

• REST: An architectural style that came out of Roy Fielding's 2000 doctoral dissertation. HTTP verbs (GET/POST/PUT/PATCH/DELETE) + resource URLs. The most widespread.
• GraphQL: A single-endpoint + query-language model that came out of Facebook in 2015. The user can pick which fields to receive.
• gRPC: Google's high-performance RPC framework that runs over HTTP/2 with Protocol Buffers. Common for internal microservice-to-microservice communication.
• Webhook: Server-to-server callback. "When this event happens, notify me at this URL."
• WebSocket / SSE: Real-time, persistent connections.

For the REST vs GraphQL comparison see our GraphQL vs REST article; for the WebSocket vs SSE choice our WebSocket vs SSE article; and for REST security our REST API security guide are detailed references.

Common Misconceptions About the Web

To wrap up, let's look at seven things commonly heard in everyday speech that are technically wrong or only half-right:

• "If the site doesn't open without typing WWW, hosting is broken" — false. www is a subdomain and that's a DNS issue, not a hosting issue. You need separate CNAME/A records for www and the apex (example.com).
• "HTTP is slow, HTTPS is fast" — half-true. The HTTPS handshake adds overhead, but because HTTP/2 and HTTP/3 only run over HTTPS, an HTTPS site is faster in practice.
• "I have a web site, so I'm on the internet" — until your site is indexed in Google and properly SEO-optimized, no one will find you. Being live is not the same as being visible.
• "HTML is a programming language" — no. HTML is a markup language; there's no flow control, no variables, no functions.
• "The internet and the web are the same thing" — no. We covered this in detail.
• "Browsers create viruses" — modern browsers run each tab in a sandbox and can't access system files directly. The threat usually comes from downloaded files or browser extensions.
• "Content generated by AI is Web 4.0" — Web 4.0 is broader; AI is just one piece.

Helper Tools for Building on the Web

Within brandname we offer a few free tools that let you run the most commonly asked technical web checks with a single click.

• DNS Lookup — instantly fetch A/AAAA/CNAME/MX/TXT records
• WHOIS Lookup — domain owner and registration info
• SSL Certificate Check — certificate validity, chain, expiry
• Site Speed Test — page load time and Core Web Vitals
• HTTP Header Check — view response headers
• Ping and Traceroute — network path analysis

Frequently Asked Questions

Are the web and the internet the same thing?

No. The internet is the physical + logical network infrastructure (since 1969). The web is a service that runs on top of the internet (since 1989). Email, FTP, SSH, DNS, and gaming protocols are other services on the internet.

What does WWW stand for?

It's short for World Wide Web. It's the hypertext-based information system Tim Berners-Lee built at CERN in 1989. In modern browsers the www. prefix is not required; it's a matter of preference.

Who invented the web?

British physicist-engineer Sir Tim Berners-Lee, in 1989 at CERN. On a NeXT computer he built the first web server, the first browser, and the first web page. He founded W3C in 1994. He received the Turing Award in 2017.

What's the difference between a web page and a web site?

A web page is a single HTML document. A web site is a collection of multiple web pages grouped under the same domain. This article is a web page; the brandname Blog it lives in is a web site.

Is Web 3.0 real, or is it hype?

It has two meanings. Tim Berners-Lee's Semantic Web vision is still alive (with schema.org, JSON-LD, structured data). The crypto/blockchain version of "Web3" is more speculative. Which one wins remains to be seen; both are technologically real.

How much does it cost to launch a web site?

Approximate (varies by provider, 2026 figures): domain around $8–25 USD/year, shared hosting around $2–6 USD/month, SSL free (Let's Encrypt) or $10–150 USD/year, basic DIY setup $0 or with an agency around $200–2,500 USD. Details in our hosting article.

What language is the web built in?

On the client side, HTML + CSS + JavaScript are mandatory. On the server side, dozens of options exist: Node.js, PHP, Python, Ruby, Go, Rust, Java, C#, and more. There is no single right choice; it depends on the team's expertise and the project's requirements.

References

• w3.org — World Wide Web Consortium
• html.spec.whatwg.org — HTML Living Standard
• url.spec.whatwg.org — URL Living Standard
• RFC 9110 — HTTP Semantics (2022)
• RFC 9114 — HTTP/3 (2022)
• MDN Web Docs — broad web documentation
• info.cern.ch — the original 1991 web page
• web.dev — Google's modern web guides
• caniuse.com — browser support tables
• WebAIM — WCAG — the accessibility standard
• OWASP Top 10 — security threats

Related Articles

• What Is DNS? DNS Settings — fundamentals of name resolution
• What Is Hosting, Hosting Types — where the site lives
• What Is a Domain, WHOIS — domain name basics
• HTTPS and TLS 1.3 — how the secure web works
• Core Web Vitals 2026 — modern performance metrics
• Site Optimization — end-to-end speedup
• Search Engines and SEO — being findable