Learn Go from zero by building and shipping a real, production personal portfolio site — the standard library's own router, server-rendered HTML, plain CSS and vanilla JS, a real Postgres database on Supabase, and deployment to Vercel with your own domain.
Section 1
A portfolio site has a deceptively modest job: present your work clearly, load fast, and stay cheap and easy to keep running for years. Go is a genuinely good fit for exactly that job.
A portfolio site has a simple job: present your work clearly, load quickly, and remain easy to maintain. It does not need to prove that you use the largest framework or the most fashionable build pipeline. In many cases, the better engineering decision is to choose a small set of dependable tools and let the content take center stage. That is where Go fits especially well.
Go is deliberately simple. Its syntax is compact, its formatting conventions are consistent (there's one canonical way to format any Go file, enforced by gofmt, so you never argue about style), and the standard library provides most of the foundations needed for a web application. For a portfolio, that means you can focus on HTTP handlers, templates, database access, and content rather than learning several layers of framework-specific conventions. As a beginner, you can understand the whole application without tracing dependencies through dozens of packages. As you grow, you can still read, test, and modify it quickly, because nothing about it is hidden behind "magic."
Go also compiles down to a single static binary. Once your code is built, the application and its Go dependencies travel together as one file — there's no language runtime to install separately, no node_modules directory to sync, and no separate step to "install dependencies" on the server before your app can run. This makes local development, container images, and production releases straightforward: you build once, and you run the resulting binary anywhere with a matching OS/architecture. Compilation is also fast — a project this size builds in well under a second on a modern machine — which keeps the edit-build-run loop pleasant even as the project grows. And the standard library is unusually stable: packages like net/http, html/template, and database/sql have kept the same core APIs for well over a decade, so code you write today keeps working without a framework major-version migration forcing rewrites down the line.
None of this makes Node.js or Next.js the wrong choice — they're excellent, and for a lot of teams and a lot of sites, they're the more productive option. Next.js gives you file-based routing, React components, a huge ecosystem of UI libraries, and a development experience tuned for highly interactive, client-heavy interfaces. If your portfolio needed rich client-side interactivity — live filtering, animated transitions between views, a dashboard-like feel — Next.js's tooling would genuinely save you time.
A personal portfolio, though, is mostly static content: a handful of pages, some project write-ups, a contact form. It doesn't need a client-side rendering framework to feel fast — server-rendered HTML, delivered over a fast connection, is often faster to first paint than a page that has to download and execute a JavaScript bundle before it can render anything. Go's trade is honest: you give up some of Next.js's ecosystem convenience and built-in interactivity tooling, and in exchange you get a smaller, simpler system — one language, one compiled artifact, no build step, no bundler configuration, no dependency tree to audit for vulnerabilities every few weeks.
By the end of this course you'll have a real, deployed personal portfolio site built the way this course's own site is actually built: routing with the standard library's net/http pattern-based router (no third-party router dependency), pages rendered server-side with html/template, styling with plain CSS using custom properties for a consistent design system, a few small vanilla-JS touches for interactivity, a real Postgres database hosted on Supabase — connected directly from Go using the pgx driver, not Supabase's client SDK — and a deployment to Vercel as a Go serverless function, finished off with your own custom domain.
This course teaches you to build a clean, focused portfolio: a home page, an about/bio page, a projects or work-experience section, and a contact form. It deliberately does not cover payment integration, a paid-content gating system, or an appointment-booking system — those are real, substantial systems in their own right, and they're covered in a separate follow-up course. Here, the goal is a genuinely solid foundation: a site you understand completely, from the HTTP request down to the database row.
By the time you finish, you won't just have a deployed portfolio — you'll understand how a real Go web application is structured, how server-rendered pages are produced, how to talk to a production database safely, and how to ship a small system with confidence, on infrastructure you configured yourself. That's a foundation that transfers directly to your next Go project, whatever it turns out to be.
Section 2