Before you publish a personal site or a small project page, you will encounter two related but distinct concepts: the domain name and the full URL. Confusing them can lead to mislabeled links, broken bookmarks, or unclear communication with collaborators. This article uses a single hypothetical address to show what each piece means and how to keep track of them.
What Question Does Each One Answer?
Suppose you are preparing a small portfolio site and someone asks, “What is your website address?” You might reply with a domain name like example.org, or you might give a longer string that includes a path and extra parameters. Both answers are useful, but they respond to different questions. A domain name identifies the server or host where your content lives. It provides a human-readable label for what would otherwise be a numeric IP address that computers handle easily but people find hard to remember. A complete URL, on the other hand, identifies a specific resource on that server—a particular page, image, or document—and tells the browser exactly how to retrieve it.12
Think of it this way: the domain name answers “which building?” while the full URL answers “which room in that building, and how should I get there?” A domain name such as example.org tells the browser which web server to contact. A URL such as https://example.org/notes/first-page goes further by specifying a particular resource on that server. The MDN documentation on URLs describes the URL as the address of a unique resource on the internet and one of the key mechanisms browsers use to retrieve published resources like HTML pages, CSS documents, and images. The domain name documentation explains that domain names are a key part of internet infrastructure because they provide a human-readable address for any web server available on the internet.12
For a first-time site builder, this distinction matters because you will use the domain name when talking about your site in general—for instance, when telling a friend where to find your work. You will use the full URL when linking to a specific page within your site, sharing a particular article, or debugging why one page loads correctly while another does not. Keeping these two concepts separate in your mind from the start saves confusion later.
Reading the Example Address Piece by Piece
To make these ideas concrete, we will use a hypothetical address string throughout this article: https://example.org/notes/first-page?view=compact#intro. This address is invented purely for the purpose of breaking down its components. It does not point to a real, live page, and no one needs to register or host it. Treat it as a labeled diagram rather than a working link.
Starting from the left, https is the scheme. It indicates the protocol the browser should use when requesting the resource. The scheme is separated from the next part by the character pattern ://. Following the scheme comes the authority section, which in this example is example.org. This is the domain name that identifies the web server. The part after the domain and before any question mark is the path: /notes/first-page. The path tells the server which resource is being requested. After the question mark comes the query string: view=compact. The question mark signals the start of query parameters, which are key-value pairs that provide extra information to the server. Finally, the hash symbol # introduces the fragment: intro. The fragment acts like a bookmark inside the resource, directing the browser to a specific spot within the page rather than sending additional information to the server.2
Two punctuation marks deserve special attention because they are easy to confuse. The question mark always introduces the query section; everything after it and before any hash symbol belongs to the query. The hash symbol always introduces the fragment; everything after it is a local reference within the document and is never sent to the server with the request. If you see both in one address, the question mark comes first and the hash comes last. This ordering is a structural rule of how URLs are composed, not a suggestion.2
Same Host, Different Paths and Queries
Now keep the host portion—example.org—fixed and change only the path or the query string. Compare https://example.org/notes/first-page?view=compact#intro with https://example.org/notes/second-page?view=full. The domain is identical, but the path points to a different resource and the query carries a different value. The fragment is absent in the second version, meaning the browser would display the page from its default starting position rather than jumping to a bookmarked section. These are distinct URLs even though they share the same host.
Next, compare https://example.org/notes/first-page with https://example.org/notes/first-page?view=compact. The path is the same, but the second version includes a query parameter. Whether the server actually does anything different with that parameter depends entirely on how the server is configured. From the string alone, you can observe that the parameter is present, but you cannot determine what the server will do with it. This is an important habit for beginners: describe what you see in the string without assuming server behavior you have not verified.
Finally, consider https://example.org/notes/first-page#intro versus https://example.org/notes/first-page. The only difference is the fragment. Because the fragment is never sent to the server with the request, both addresses would retrieve the same resource from the server’s perspective. The fragment only affects how the browser displays the content locally—specifically, whether it scrolls to the element identified as intro. Recognizing this distinction helps when you are troubleshooting why two links appear to load the same page but show different scroll positions.2
Building an Address Description Card
When you are preparing your own site, a simple address description card can keep your information organized. This is a personal record, not a formal document. Write down the purpose of the page, the complete URL you intend to use, and then list each part with a short label. For our hypothetical example, the card might read: Purpose—a compact view of the first notes page. Full address—https://example.org/notes/first-page?view=compact#intro. Scheme—https. Domain—example.org. Path—/notes/first-page. Query—view=compact. Fragment—intro.
Record why you chose each part, even briefly. For instance, you might note that the path /notes/first-page reflects your folder structure and the page slug you selected during planning. You might write that the query parameter view=compact is intended to trigger a condensed layout, based on how your site template handles that parameter. The fragment intro exists because you placed an element with that identifier near the top of the page and want shared links to land there. These notes are for your own reference; they do not need to follow any external standard.
The value of this card becomes clear when you need to communicate your address to someone else or return to it after a break. Instead of staring at a long string and trying to remember which part is the query and which is the fragment, you can glance at your card and immediately see the structure. It also helps you spot errors—if you accidentally place a hash where a question mark should go, the card makes the mismatch visible during review.
Verifying Your Card by Hand
Once your card is written, verify it by copying the full URL into a plain text editor and labeling each segment manually. This low-tech check catches mistakes that are easy to overlook when you are thinking about content rather than structure. The process is straightforward and takes only a few minutes.
Check that the scheme matches what you recorded. Look for the :// separator and confirm that the domain immediately follows it. Then find the first forward slash after the domain—that marks the beginning of the path. Locate the question mark and confirm that everything between it and the hash (if present) is your query string. Finally, locate the hash and confirm that everything after it is the fragment. Write these labels next to the corresponding substrings in your text editor.
Compare your labeled segments against the card entry. If any segment is missing, misplaced, or spelled differently from what you recorded, correct the card or the URL before you use it anywhere public. This step is especially useful when you have multiple pages with similar paths, because a single misplaced slash or an extra character in the query can produce an address that looks right at a glance but points somewhere unexpected.
Step 1
Copy the full URL from your card and paste it into a plain text editor or a blank document.
Step 2
Starting from the left, mark the scheme, then the :// separator, then the domain. Write a short label above or below each segment.
Step 3
Find the first slash after the domain and label everything from that slash up to the question mark (or the end of the string if there is no question mark) as the path.
Step 4
If a question mark is present, label everything between it and the hash symbol (or the end of the string) as the query. If a hash symbol is present, label everything after it as the fragment.
Keeping the Record for Future Use
After you have verified your address card, store it somewhere you will actually find it later—a project notes file, a shared document with your collaborator, or a dedicated section in your site planning folder. The format does not matter as long as you can locate it quickly when you need to share a link, write documentation, or troubleshoot a page that is not loading as expected.
As your site grows, you will likely accumulate several addresses with different paths and query combinations. The same card approach scales: add one entry per page or per link variant you want to track. When you eventually hand your site to another person for review or maintenance, these cards give them a clear starting point without requiring them to reverse-engineer your URL structure from scratch.
The habit of writing down and verifying your addresses is a small investment that pays off whenever you need to explain your site’s structure to someone else, file a support request, or simply remember why you chose a particular path six months ago. It turns an opaque string of characters into a set of named, intentional choices that you can revisit and adjust as your project evolves.
Frequently asked questions
Is a domain name the same thing as a URL?
No. A domain name identifies the web server (for example, example.org), while a URL identifies a specific resource on that server and includes additional parts such as the scheme, path, query, and fragment. Every URL contains a domain name, but a domain name alone is not a complete URL.12
What is the difference between the query string and the fragment in a URL?
The query string begins with a question mark and sends key-value pairs to the server as part of the request. The fragment begins with a hash symbol and acts as a local bookmark within the page; it is never sent to the server. In our example, view=compact is the query and intro is the fragment.2
Do I need to understand every part of a URL before launching a site?
You do not need to master every optional component, but knowing the basic structure—scheme, domain, path, query, and fragment—helps you write correct links, communicate with collaborators, and troubleshoot pages that do not load as expected. The address card method described in this article is a practical way to build that familiarity without needing deep technical knowledge.