Publishing.

The big picture

Publishing has three pieces: getting your code into GitHub (so you have version history and a place to push from), choosing a host (GitHub Pages or Netlify, mostly), and pointing a domain at it (Porkbun is what I use). Let's walk through each.

Step 0: Get a GitHub account

If you've never used GitHub before, here's the quick orientation. GitHub is a free service for storing code online. It's also a backup, a version history (so you can roll back to any earlier version of your project), and the launchpad for putting your site on the web. Free for public projects (which is what we'll use).

1. Sign up at github.com

   Click "Sign up." Pick a username — keep it professional, you'll be sharing repo URLs that include this name. Use a real email. Free plan is fine.

2. Verify your email

   GitHub will send a confirmation. Click the link.

3. Skip the onboarding fluff

   GitHub will try to walk you through tutorials and ask which features you want. You can skip past most of it.

4. Make your first repo

   Click the green "+" or "New" button. Name it (e.g. my-first-site or your client's name). Set it to Public if you want to use the free GitHub Pages hosting. Don't check "Initialize this repository with a README" — leave it empty so your local files can be the first thing in there. Click "Create repository."

5. Leave the resulting page open

   GitHub will show you a page with code snippets ("…or push an existing repository from the command line"). You'll use those in the next step.

Step 1: Get your code on GitHub

Even if you never deploy from GitHub, this step is non-negotiable. GitHub is your backup, your version history, and your "I broke it, give me yesterday" insurance.

If you're using Claude Code

Inside your project folder, ask Claude:

Claude will run all the right commands. If it gets stuck on authentication (GitHub asks for a token instead of a password these days), Claude will tell you what to do — usually involves creating a "Personal Access Token" in GitHub settings, which Claude will walk you through.

If you're not using Claude Code

Use GitHub Desktop — it's free, has a graphical interface, and skips the terminal entirely. After installing:

1. Sign in with your GitHub account.
2. File → "Add Local Repository" → pick your project folder.
3. It'll prompt you to create a Git repo if there isn't one — say yes.
4. Make your first commit (write a message like "first commit," click Commit).
5. Click "Publish repository" at the top → uncheck "Keep this code private" if you want it public → Publish.

Done. Your code is on GitHub.

Step 2: Pick a host

Two realistic free options for static HTML sites: GitHub Pages and Netlify. Here's the comparison:

Feature	GitHub Pages	Netlify
Cost (small site)	Free	Free tier, then paid
Setup difficulty	Very easy (one toggle in repo settings)	Easy (connect GitHub repo)
Auto-deploy on push	Yes	Yes
Custom domain	Yes (HTTPS included)	Yes (HTTPS included)
Forms (e.g. contact form)	No	Yes (100 submissions/month free)
Redirects & rewrites	Limited	Yes
Build limits	Generous (effectively unlimited for static sites)	300 build minutes/month free, then $7/mo for more
Bandwidth	100 GB/month soft limit	100 GB/month free, then paid

When to use GitHub Pages

Static site, no forms, no fancy redirects, just HTML/CSS/JS. Most personal sites and small business sites fit here. Free, no surprises, and the URL pattern is username.github.io/repo-name (or your custom domain if you set one up).

When to use Netlify

You need contact form submissions, you want preview URLs for branches, or you're going to use serverless functions later. Most client work that needs a contact form ends up on Netlify.

GitHub Pages walkthrough

1. Push your code to GitHub

   Per Step 1 above. Make sure your main file is called index.html at the root of the repo.

2. Enable Pages

   Go to your repo on github.com → Settings → Pages. Under "Source," pick "Deploy from a branch." Pick main and / (root). Save.

3. Wait 1–2 minutes

   GitHub will build and deploy your site. Refresh the Pages settings page — when it's ready, the URL appears at the top.

4. Visit and test

   Your site is live at https://yourname.github.io/repo-name/. Open it on your phone. Walk through every page. Check images load.

Netlify walkthrough

1. Sign up

   Go to netlify.com and sign up with your GitHub account.

2. Import your repo

   Click "Add new site" → "Import existing project" → "Deploy with GitHub" → pick your repo. Netlify auto-detects static sites; you can leave the build settings blank.

3. Wait ~30 seconds

   First deploy is fast for static sites. You'll get a random URL like silver-river-12345.netlify.app.

4. Rename the URL

   Site Settings → Site information → "Change site name." Pick something clean — acf-foster-youth.netlify.app beats the random one.

5. Auto-deploys are on

   From now on, every push to main triggers a new deploy automatically. (See the build minutes warning above.)

Step 3: Custom domain

Both GitHub Pages and Netlify support custom domains. The flow is the same: buy a domain at a registrar, point its DNS at your host. I use Porkbun because it's cheap and the interface isn't aggressive about upsells.

Buy the domain

1. Go to porkbun.com, search the domain, buy it. Most .com domains run $10–15/year. Skip the upsells (privacy is included free, hosting upsells you don't need).
2. You now own the domain.

Point DNS

The exact steps differ depending on host. The cleanest method is using Porkbun's name servers when you don't need email tied to the domain — but for most clients I use direct A and CNAME records so they keep control.

For Netlify

1. In Netlify: Site Settings → Domain management → Add custom domain → enter your domain.
2. Netlify shows you the DNS records to add. Usually an A record pointing at Netlify's IP, and a CNAME for www.
3. In Porkbun: Domain Management → DNS Records → add the records Netlify gave you.
4. Wait. DNS propagation can take 10 minutes to several hours.
5. Netlify will auto-issue an HTTPS certificate (Let's Encrypt) once DNS propagates. No action needed.

For GitHub Pages

1. In your repo: Settings → Pages → Custom domain → enter your domain. GitHub creates a CNAME file in your repo.
2. In Porkbun: add four A records pointing at GitHub Pages' IPs (185.199.108.153, 185.199.109.153, 185.199.110.153, 185.199.111.153) plus a CNAME for www pointing at yourname.github.io.
3. Wait for propagation. Once it lands, in your repo's Pages settings, check "Enforce HTTPS."

Cost summary across the whole stack

Service	What it costs	How you can rack up charges
GitHub	Free for public repos	Private repos with multiple collaborators may need a paid plan ($4/mo)
GitHub Pages	Free	Almost impossible to overage at small-site scale
Netlify	Free tier, $19/mo Pro	Going over 300 build minutes or 100 GB bandwidth in a month
Cloudinary	Free tier (25 GB), then $99/mo+	Uploading lots of unused images, hot weeks of traffic
Porkbun (domain)	$10–15/year	Auto-renewal you forgot about, premium domain markup
Anthropic API (Claude Code)	Pay-per-use; usually a few cents per build session	Long sessions with massive context (paste of huge files repeatedly)

Common mistakes

• Putting client review on Netlify before the site is final. Use GitHub Pages for review. Move to Netlify when the site is locked.
• Not enforcing HTTPS. Both GitHub Pages and Netlify have a one-click toggle. Always on.
• Pushing 50 tiny commits during the final week. Burns build minutes on Netlify. Bundle changes.
• Forgetting to renew the domain. Set Porkbun to auto-renew. Losing a client's domain is the worst.
• Storing API keys in your repo. If you start using Anthropic API or Stripe in your sites, never commit the keys. Use environment variables.
• Not testing the live site after deploy. Localhost is not the live site. Open the deployed URL on your phone and on a desktop browser. Click every link. Submit forms.

What's next

Site is live. The hard part is over. Next chapter is the field guide for what tends to go wrong after launch — and how to dodge the most common traps.