When you prepare your first website, you will encounter two related but distinct concepts: the domain name and the full URL. Confusing them can lead to miscommunication with collaborators or mistakes when setting up links. This article uses one hypothetical address to show exactly what each part means and how to document it for your own project.
What a Domain Name Answers Versus What a Full URL Answers
Suppose you are planning a small personal site to collect reading notes. You have heard you need a domain name, and someone on a forum told you to “just pick a URL.” These two pieces of advice are pointing at different things. A domain name is the human-readable label that identifies a web server on the Internet. It exists so that people do not have to memorize numeric IP addresses like 192.0.2.172. A domain name such as example.org tells you which server to reach, but it says nothing about which specific page or resource you want from that server.1
A full URL answers a much more specific question: exactly which resource on that server should the browser retrieve? A URL includes the domain name but adds further instructions such as the protocol to use, the path to a particular document, optional parameters, and an optional anchor point within the document. In theory each valid URL points to a unique resource, though in practice a URL may reference something that has moved or no longer exists.2
For our reading-notes project, this distinction matters because you will eventually share addresses with readers, embed links in your pages, and perhaps configure tools that need the exact string. Knowing which part of the address does what job prevents you from accidentally sharing a bare domain when you meant to point to a specific page.
Reading the Example Address Part by Part
To make this concrete, we will use one hypothetical address throughout this article: https://example.org/notes/first-page?view=compact#intro. This is a fabricated string created purely for dissection; it does not point to a real page. Treating it as a specimen lets us label every component without worrying about whether the page actually loads.
The first segment, https, is the scheme. It tells the browser which protocol to use when requesting the resource; for ordinary websites this is typically HTTPS or its unsecured version HTTP. The authority section follows the pattern :// and contains the domain name, which in our example is example.org. The domain indicates which web server is being requested.2
After the domain comes the path /notes/first-page. The path identifies a specific resource on that server. Historically it represented a physical file location, but today it is mostly an abstraction handled by the web server. Following the path, the question mark introduces the query string view=compact. Parameters are extra key-value pairs provided to the web server, and the server can use them to do additional processing before returning the resource. Finally, the hash symbol introduces the fragment identifier intro, which acts as a bookmark inside the resource itself, directing the browser to scroll to a particular spot. The fragment is never sent to the server with the request.2
Comparing Strings With the Same Host
Now keep the host portion example.org unchanged and imagine two variations: https://example.org/notes/second-page?view=compact#intro and https://example.org/notes/first-page?view=expanded#intro. In the first variation only the path changed from first-page to second-page. In the second variation only the query parameter changed from compact to expanded. Each produces a different string, and each would be treated as a distinct URL by the browser.2
This observation is important for documentation. When you record addresses for your project, you should note which part carries the meaningful difference. A path change typically means a different document or section of the site. A query change may alter how the same document is displayed or filtered, but the underlying resource could be the same. We cannot determine what the server actually does with these parameters just by looking at the string; each web server has its own rules regarding parameters, and the only reliable way to know how a specific server handles them is by asking the server owner.2
For your reading-notes project, this means you should decide early whether different views of the same note will use query parameters or separate paths. That decision affects how you write links in your content and how you describe your pages to others. Recording the reasoning alongside the address prevents confusion later when you revisit the project after a break.
Building an Address Description Card
Write down a short card for each address your project will use. The card should have four fields: the purpose of the address in plain language, the full URL string, a list of its component parts with labels, and any notes about choices you made. For our hypothetical example, the purpose field would read “first reading note displayed in compact view, anchored to the introduction section.” The full address field holds the exact string https://example.org/notes/first-page?view=compact#intro. The parts field lists scheme as https, host as example.org, path as /notes/first-page, query as view=compact, and fragment as intro.
This card format is a personal organizational choice, not a requirement imposed by any standard. Its value lies in forcing you to name each component explicitly rather than treating the address as an opaque block of characters. When you later need to explain your site structure to a collaborator or troubleshoot a broken link, having the breakdown already written saves time and reduces errors.
If your project grows to include multiple pages, maintain one card per address. Keep them together in a single document or note file so you can scan them quickly. Over time this collection becomes a simple map of your site’s address space, which is useful when you add new sections or rename existing ones.
Verifying the Card by Hand
Check your card against the actual address string by copying the URL into a plain-text editor and inserting a line break after each component boundary. Place one break after the scheme and the :// separator, one after the host, one after the path, one after the query string, and one after the fragment. This visual separation makes it easy to spot a missing question mark, a stray slash, or a misspelled parameter name.
Record the result of this check next to each field on your card. If everything matches, write “verified” with the date. If you find a discrepancy, correct the card and note what was wrong. This small habit catches typos that would otherwise surface only when a reader reports a broken link.
Repeat this verification any time you change the address, even for a seemingly minor edit like adding a trailing slash or capitalizing a letter. Paths on many servers are case-sensitive, so a change that looks cosmetic in your notes file could produce a different resource or an error. Treating every character as meaningful keeps your documentation reliable.
Keeping the Record for Future Use
Store your completed cards in a location you will actually revisit. A plain-text file in your project folder works well because it can be searched, versioned, and shared without special tools. Some people prefer a spreadsheet; others keep a section in their project wiki. The format matters less than the commitment to update the cards whenever the address changes.
When you write new content or communicate your site structure to someone else, refer back to the card rather than reconstructing the address from memory. This reduces the chance of introducing a subtle error into a link or an instruction. It also gives you a ready-made explanation if a collaborator asks what a particular query parameter does or why you chose a specific path structure.
Over the life of your project these cards accumulate into a lightweight reference that captures not just the addresses but the reasoning behind them. That context is difficult to recover later, so recording it at the moment of decision is the most efficient approach. Your future self, returning to the project after weeks or months, will benefit from the clarity you built today.
Frequently asked questions
Is the domain name the same thing as the URL?
No. A domain name identifies the server, while a URL is a complete address that also specifies the protocol, path, and optionally parameters and a fragment. The domain is one component within the URL.12
Does the fragment part after the hash symbol get sent to the server?
No. The fragment identifier is never sent to the server with the request. It is used only by the browser to locate a position within the already-loaded resource.2
Can I tell what a query parameter does just by looking at the URL?
Not reliably. Each web server has its own rules for handling parameters. The string tells you the parameter name and value, but only the server owner can confirm what effect they have.2