Custom domains in Deno - Deep Dive

Overview - Custom domains

What is it?

Custom domains let you use your own website address instead of a default one provided by a service. For example, instead of myapp.deno.dev, you can use myapp.com. This makes your site look professional and easier to remember. Setting up a custom domain involves linking your domain name to your Deno app hosting.

Why it matters

Without custom domains, websites look less trustworthy and harder to find. People might forget long default URLs or think the site is temporary. Custom domains build brand identity and trust, making visitors more likely to return. They also allow better control over your online presence.

Where it fits

Before learning custom domains, you should understand basic web hosting and DNS concepts. After mastering custom domains, you can explore SSL certificates, HTTPS setup, and advanced DNS configurations for security and performance.

Mental Model

Core Idea

A custom domain connects your unique website name to your Deno app by linking DNS records to the hosting service.

Think of it like...

It's like giving your house a personalized street address instead of a generic apartment number, so visitors can find you easily and remember where you live.

┌─────────────┐       ┌───────────────┐       ┌───────────────┐
│ Your Domain │──────▶│ DNS Provider  │──────▶│ Deno Hosting  │
│ (myapp.com) │       │ (manages DNS) │       │ (runs app)    │
└─────────────┘       └───────────────┘       └───────────────┘

Build-Up - 7 Steps

1

Foundation

What is a domain name

Concept: Introduce the idea of domain names as human-friendly website addresses.

A domain name is the web address people type to visit a site, like example.com. It replaces hard-to-remember IP addresses, which are numbers computers use to find each other. Domains are registered through companies called registrars.

Result

You understand that domain names are the easy-to-remember labels for websites.

Knowing what a domain name is helps you see why custom domains matter for user experience and branding.

2

Foundation

Basics of DNS and records

Concept: Explain how DNS translates domain names to IP addresses using records.

DNS (Domain Name System) is like the internet's phone book. It stores records that tell browsers where to find your website. Common records include A (points to IP), CNAME (aliases one name to another), and TXT (for verification).

Result

You grasp how DNS connects domain names to servers hosting websites.

Understanding DNS is key to configuring custom domains correctly.

3

Intermediate

How Deno deploys apps with default domains

Concept: Show how Deno deploys apps with default subdomains before custom domains.

When you deploy a Deno app, it gets a default address like yourapp.deno.dev. This address is managed by Deno's hosting and DNS. It works immediately but is not personalized.

Result

You see the starting point before adding your own domain.

Recognizing default domains clarifies why custom domains add value.

4

Intermediate

Linking your domain to Deno app

🤔Before reading on: Do you think linking a domain requires changing your app code or just DNS settings? Commit to your answer.

Concept: Explain that linking a custom domain mainly involves DNS changes and Deno configuration, not app code changes.

To use your domain, you update DNS records at your registrar to point to Deno's servers. Then, in Deno's dashboard or CLI, you verify ownership and assign the domain to your app. No code changes are needed.

Result

Your domain points to your Deno app, making it accessible via your custom address.

Knowing that DNS and hosting config handle domains prevents confusion about needing code changes.

5

Intermediate

Verifying domain ownership

🤔Before reading on: Do you think domain verification is optional or mandatory for custom domains? Commit to your answer.

Concept: Introduce domain verification as a security step to prove you own the domain.

Deno requires you to prove ownership by adding a special TXT record to your DNS. This prevents others from hijacking your domain. Once verified, Deno allows the domain to serve your app.

Result

Your domain is securely linked to your app, preventing misuse.

Understanding verification protects your site and builds trust with users.

6

Advanced

Setting up HTTPS with custom domains

🤔Before reading on: Do you think HTTPS setup is automatic or manual when using custom domains on Deno? Commit to your answer.

Concept: Explain how HTTPS certificates are issued and managed for custom domains on Deno.

Deno automatically provisions SSL/TLS certificates via Let's Encrypt for your custom domain. This enables secure HTTPS connections without manual certificate handling. You just need to ensure DNS is correctly set.

Result

Visitors access your site securely with HTTPS and a padlock icon.

Knowing HTTPS is automatic removes a common barrier to secure websites.

7

Expert

Handling DNS propagation and caching delays

🤔Before reading on: Do you think DNS changes take effect instantly or can they be delayed? Commit to your answer.

Concept: Discuss how DNS changes take time to spread worldwide and how caching affects this.

When you update DNS records, it can take minutes to hours for changes to reach all internet servers due to caching. This delay is called propagation. Understanding this helps troubleshoot why your domain might not work immediately after setup.

Result

You anticipate and manage delays in domain setup, avoiding confusion.

Knowing about propagation prevents frustration and misdiagnosis of setup problems.

Under the Hood

When you set a custom domain, your DNS provider stores records that point your domain to Deno's hosting IP addresses or CNAMEs. When a user types your domain, their browser queries DNS servers to find these records, then connects to Deno's servers to load your app. Deno verifies domain ownership by checking for specific TXT records you add. For HTTPS, Deno uses automated certificate issuance with Let's Encrypt, renewing certificates before expiration.

Why designed this way?

This design separates domain management (DNS) from app hosting, allowing flexibility and security. Verification prevents domain hijacking. Automated HTTPS simplifies security for developers, removing manual certificate handling. Alternatives like manual certificate management or hosting your own DNS would increase complexity and risk.

┌─────────────┐       ┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ User Browser│──────▶│ DNS Resolver  │──────▶│ DNS Provider  │──────▶│ Deno Hosting  │
│ (requests)  │       │ (finds IP)    │       │ (stores DNS)  │       │ (serves app)  │
└─────────────┘       └───────────────┘       └───────────────┘       └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think you must change your app's code to use a custom domain? Commit yes or no.

Common Belief: You must rewrite your app to recognize the new domain name.

Reality: No code changes are needed; domain linking is done via DNS and hosting configuration.

Why it matters: Thinking code changes are needed wastes time and causes unnecessary complexity.

Quick: Do you think DNS changes take effect immediately? Commit yes or no.

Common Belief: Once you update DNS, your domain works instantly everywhere.

Reality: DNS changes can take minutes to hours to propagate worldwide due to caching.

Why it matters: Expecting instant changes leads to confusion and repeated unnecessary edits.

Quick: Do you think HTTPS is automatically enabled for custom domains on Deno? Commit yes or no.

Common Belief: You must manually buy and install SSL certificates for your custom domain.

Reality: Deno automatically provisions and renews HTTPS certificates for custom domains.

Why it matters: Believing manual setup is required can discourage developers from securing their sites.

Quick: Do you think domain verification is optional for custom domains? Commit yes or no.

Common Belief: You can link any domain without proving ownership.

Reality: Verification via DNS TXT records is mandatory to prevent domain hijacking.

Why it matters: Skipping verification risks security breaches and domain misuse.

Expert Zone

1

DNS TTL (Time To Live) settings affect how long records are cached, influencing propagation speed and update control.

2

Using CNAME records for root domains is often unsupported; alternatives like ALIAS or ANAME records or A records are needed.

3

Automated HTTPS provisioning depends on domain verification and DNS correctness; misconfigurations can cause certificate failures.

When NOT to use

Custom domains are not suitable if you want anonymous or temporary hosting without domain ownership. Alternatives include using default subdomains or dynamic DNS services for ephemeral apps.

Production Patterns

In production, teams automate domain verification and DNS updates via APIs. They monitor DNS health and certificate status to ensure uptime. Multi-region DNS and CDN integration optimize performance and reliability.

Connections

DNS

Custom domains build directly on DNS concepts.

Mastering DNS is essential to understand how custom domains route traffic to your app.

SSL/TLS Certificates

Custom domains require SSL/TLS for secure HTTPS connections.

Knowing certificate issuance and renewal helps maintain secure custom domains.

Postal Addressing Systems

Custom domains are like postal addresses directing mail to the right house.

Understanding addressing systems in mail delivery clarifies how domain names guide internet traffic.

Common Pitfalls

#1 Updating DNS records but forgetting to verify domain ownership in Deno.

Wrong approach:

Add A or CNAME records only, then expect the domain to work immediately without verification.

Correct approach:

Add DNS records and also add the required TXT record for verification in your DNS provider, then complete verification in Deno.

Root cause:

Misunderstanding that DNS pointing alone is enough without ownership proof.

#2 Using a CNAME record at the root domain where it's not supported.

Wrong approach:

Set CNAME record for example.com pointing to yourapp.deno.dev.

Correct approach:

Use A records or ALIAS/ANAME records for root domains, or use CNAME only on subdomains like www.example.com.

Root cause:

Not knowing DNS standards and limitations for root domain records.

#3 Expecting immediate domain availability after DNS changes.

Wrong approach:

Change DNS records and immediately test domain, assuming it should work right away.

Correct approach:

Wait for DNS propagation (up to 48 hours), or lower TTL before changes to speed up updates.

Root cause:

Lack of awareness about DNS caching and propagation delays.

Key Takeaways

Custom domains let you use your own website name instead of default hosting addresses, improving professionalism and trust.

Setting up a custom domain mainly involves configuring DNS records and verifying ownership, not changing your app code.

Deno automates HTTPS certificate provisioning for custom domains, making secure connections easy to enable.

DNS propagation delays mean domain changes are not instant; patience and proper TTL settings help manage this.

Understanding DNS, verification, and HTTPS is essential for reliable and secure custom domain setup.

Practice

1. What is the main purpose of setting a custom domain in a Deno server?

easy

A. To increase the server's processing speed

B. To use your own website name instead of a generic address

C. To automatically update the server software

D. To enable debugging features in Deno

Solution

1. Step 1: Understand what a custom domain is

   A custom domain lets you use a personalized website name instead of a default or generic address.

2. Step 2: Identify the purpose in Deno context

   Setting a custom domain in Deno allows your server to respond to your own website name, making it easier for users to find your site.

3. Final Answer:

   To use your own website name instead of a generic address -> Option B

4. Quick Check:

   Custom domain = personalized website name [OK]

Hint: Custom domain means your own website name, not generic [OK]

Common Mistakes:

• Confusing custom domain with server speed
• Thinking it updates software automatically
• Assuming it enables debugging

2. Which of the following is the correct way to set a custom domain hostname in Deno's serve function?

easy

A. serve({ url: "mydomain.com" })

B. serve({ domain: "mydomain.com" })

C. serve({ hostname: "mydomain.com" })

D. serve({ host: "mydomain.com" })

Solution

1. Step 1: Recall Deno serve options

   The serve function accepts an option called hostname to set the domain name.

2. Step 2: Match the correct option key

   Only hostname is the correct key; others like domain, host, or url are invalid here.

3. Final Answer:

   serve({ hostname: "mydomain.com" }) -> Option C

4. Quick Check:

   Use hostname option in serve [OK]

Hint: Use 'hostname' option exactly in serve function [OK]

Common Mistakes:

• Using 'domain' or 'host' instead of 'hostname'
• Passing the domain as a string without key
• Confusing 'url' with hostname option

3. Given the following code snippet, what will be the hostname the server listens on?

import { serve } from "https://deno.land/std/http/server.ts";
serve(() => new Response("Hello"), { hostname: "example.com" });

medium

A. The server will throw a runtime error

B. The server listens on localhost only

C. The server listens on all IP addresses

D. The server listens on example.com domain

Solution

1. Step 1: Examine the hostname option

   The code sets hostname: "example.com" in the serve options.

2. Step 2: Understand hostname resolution and binding

   Deno resolves "example.com" to a public IP (93.184.216.34) via DNS. If the IP is assigned to the local machine's network interfaces, the server binds successfully and listens on that domain. Otherwise, it will throw a runtime error.

3. Step 3: Typical behavior

   Usually, binding to a hostname that resolves to a public IP not assigned locally will fail. But if the environment is configured properly (e.g., hosts file or network interface), it can succeed.

4. Final Answer:

   The server listens on example.com domain -> Option D

5. Quick Check:

   Hostname option sets server listening domain [OK]

Hint: Hostname option sets server listening domain [OK]

Common Mistakes:

• Thinking server listens directly on domain without IP resolution
• Assuming default localhost behavior
• Believing it falls back to all IPs

4. You set hostname: "mydomain.com" in your Deno server but users cannot reach your site. What is the most likely cause?

medium

A. You forgot to point your domain's DNS to your server's IP address

B. The serve function does not support custom domains

C. You must use host instead of hostname

D. Deno requires a special flag to enable custom domains

Solution

1. Step 1: Verify Deno serve supports hostname

   Deno's serve supports hostname option, so options B, C, and D are incorrect.

2. Step 2: Check DNS setup

   If users cannot reach the site, the domain's DNS likely does not point to the server's IP, blocking access.

3. Final Answer:

   You forgot to point your domain's DNS to your server's IP address -> Option A

4. Quick Check:

   DNS must point domain to server IP [OK]

Hint: Check DNS points domain to server IP if unreachable [OK]

Common Mistakes:

• Assuming serve lacks custom domain support
• Using wrong option key like 'host'
• Thinking Deno needs special flags for domains

5. You want to serve your Deno app on your custom domain "myapp.com" and also allow access via localhost for testing. Which setup correctly supports both?

hard

A. Set hostname to "0.0.0.0" to listen on all interfaces including domain and localhost

B. Set hostname to "myapp.com, localhost" in a single serve call

C. Run two servers: one with hostname "myapp.com" and one with hostname "localhost"

D. Use hostname "localhost" and rely on DNS to redirect "myapp.com"

Solution

1. Step 1: Understand hostname options

   Setting hostname to "0.0.0.0" makes the server listen on all network interfaces, including your domain and localhost.

2. Step 2: Evaluate other options

   Run two servers: one with hostname "myapp.com" and one with hostname "localhost" requires two servers which is inefficient; Set hostname to "myapp.com, localhost" in a single serve call is invalid syntax; Use hostname "localhost" and rely on DNS to redirect "myapp.com" relies on DNS redirect which does not work for localhost access.

3. Final Answer:

   Set hostname to "0.0.0.0" to listen on all interfaces including domain and localhost -> Option A

4. Quick Check:

   Use 0.0.0.0 to listen on all interfaces [OK]

Hint: Use 0.0.0.0 hostname to serve domain and localhost [OK]

Common Mistakes:

• Trying to list multiple hostnames in one serve call
• Running multiple servers unnecessarily
• Relying on DNS to redirect localhost