Go - The Complete Guide

Learn Go ("Golang") from the ground up & in great depth by building multiple demo projects, incl. a REST API

12 sections, 196 lectures
Total duration: 15h 17m

Course Overview

About This Course

You’ve skimmed a few Go tutorials, maybe copied some snippets, and still feel unsure what “idiomatic Go” actually looks like when you sit down to write real code. The language feels simple—until you hit data modeling, errors, and concurrency and everything gets fuzzy.

This course gives you a structured path through Go that doesn’t stop at syntax. You’ll build understanding step by step, then reinforce it by applying concepts in multiple demo projects—so the ideas stick when you’re working on your own backend services.

By the end, you’ll be able to design and implement complete Go programs with confidence: organize code into packages, model data cleanly, handle failures predictably, and ship a working backend service that connects to a SQL database and protects endpoints with authentication.

What You'll Learn

You’ll go beyond “hello world” and learn the Go patterns you need to write maintainable programs, handle real data, and build production-style backend features.

Write core Go code
Build programs using Go’s values, variables, types, and control structures, and confidently compose logic with functions—so you can turn requirements into working code without guesswork.
Use pointers effectively
Work with pointers to control how data is passed and updated, and avoid common pitfalls when you need shared state or efficient updates across functions.
Model data structures
Structure and store data with struct types, arrays, slices, and maps, choosing the right shape for the job and manipulating collections cleanly and safely.
Build concurrent workflows
Implement concurrent execution with goroutines and coordinate work using channels, so you can design Go programs that handle multiple tasks efficiently.
Design with interfaces
Use interfaces to decouple components and write flexible code that’s easier to extend and test, while keeping implementations clean and focused.
Handle errors and packages
Apply Go-style error handling and organize code with packages, so your projects stay readable, scalable, and easier to maintain as they grow.

Ready to get started?

See enrollment options

Prerequisites

Basic programming experience in any language is strongly recommended.
No prior Go knowledge is required.

Who Is This Course For?

New Go learners
You’re new to Go and want more than quick snippets—you want a deep understanding that helps you write your own programs without constantly searching for patterns.
Working developers
You already code in another language and want to add Go to your toolkit for backend development, cloud services, or performance-focused applications.
Go refreshers
You’ve started with Go before (or used it at work) but feel gaps in fundamentals or confidence, and you want a thorough, practical reset.

Curriculum Overview

Start Now

Preview the structure and pacing of this course before you begin.

Getting Started8 lectures13m
- 01Welcome To The Course!1:05 min
- 02What Is Go? And Why Is It Awesome?1:48 min
- 03Installing Go (Alternative: Web-based Setup)1:49 min
- 04Local Code Editor Setup For Go Development1:41 min
- 05Writing a First Go Program2:03 min
- 06About The Course & Course Content1:23 min
- 07How To Get The Most Out Of This Course3:23 min
- 08Join Our Learning Community0:00 min
Go Essentials44 lectures3h 15m
- 01Module Introduction1:16 min
- 02Working with Functions & Values3:47 min
- 03Organizing Code with Packages3:53 min
- 04The Important Of The Name "main"1:53 min
- 05Understanding Go Modules & Building Go Programs4:33 min
- 06The "main" Function Is Important!3:53 min
- 07Onwards To A New Project2:22 min
- 08Working with Variables, Values & Operators5:35 min
- 09Understanding Value Types5:21 min
- 10Go Types & Null Values0:00 min
- 11Outputting Values3:13 min
- 12Type Conversions & Explicit Type Assignment4:21 min
- 13Using Alternative Variable Declaration Styles5:27 min
- 14Making Sense of Constant Values ("Constants")4:29 min
- 15Understanding the Importance Of Variables6:32 min
- 16Improved User Input Fetching5:22 min
- 17fmt.Scan() Limitations0:00 min
- 18Exercise: Building a Profit Calculator1:18 min
- 19Exercise Solution8:13 min
- 20Formatting Strings (Text) - Basics7:29 min
- 21Formatting Floats in Strings2:41 min
- 22Creating Formatted Strings3:45 min
- 23Building Multiline Strings2:26 min
- 24Understanding Functions9:04 min
- 25Functions: Return Values & Variable Scope11:07 min
- 26An Alternative Return Value Syntax2:31 min
- 27Exercise: Working with Functions8:59 min
- 28Onwards to Control Structures5:28 min
- 29Introducing "if" Statements & Booleans5:51 min
- 30Working with "else if"4:21 min
- 31Exercise: "if" Statements2:04 min
- 32Using "else"2:02 min
- 33Nested "if" Statements & Using "return" To Stop Function Execution4:51 min
- 34Repeating Code With "for" Loops4:03 min
- 35Infinite Loops, "break" & "continue"4:59 min
- 36Conditional For Loops0:00 min
- 37Making Sense of "switch" Statements5:18 min
- 38Writing To Files6:08 min
- 39Reading From Files6:47 min
- 40Handling Errors8:01 min
- 41Time to Panic!2:04 min
- 42Section Exercise - The Task1:44 min
- 43Section Exercise - Solution11:29 min
- 44Module Summary1:08 min
Working with Packages9 lectures23m
- 01Module Introduction0:54 min
- 02Splitting Code Across Files In The Same Package4:19 min
- 03Why Would You Use More Than One Package?1:32 min
- 04Preparing Code For Multiple Packages3:41 min
- 05Splitting Code Across Multiple Packages2:41 min
- 06Importing Packages1:37 min
- 07Exporting & Importing Identifiers (Variables, Functions & More)2:36 min
- 08Using Third-Party Packages5:36 min
- 09Module Summary1:00 min
Understanding Pointers10 lectures22m
- 01Module Introduction0:30 min
- 02Understanding Pointers6:04 min
- 03Writing Code Without Pointers3:17 min
- 04Creating a Pointer1:39 min
- 05A Pointer's Null Value0:00 min
- 06Pointers as Values1:56 min
- 07Using Pointers & Passing Pointers To Functions3:28 min
- 08Using Pointers For Data Mutation4:08 min
- 09Example: The Scan() Function Uses Pointers0:59 min
- 10Module Summary0:34 min
Structs & Custom Types25 lectures1h 48m
- 01Module Introduction1:07 min
- 02The Starting Project0:53 min
- 03Which Problem Do Structs Solve?2:27 min
- 04Defining A Struct Type4:43 min
- 05Instantiating Structs & Struct Literal Notation3:28 min
- 06Alternative Struct Literal Notation & Struct Null Values2:24 min
- 07Passing Struct Values As Arguments2:33 min
- 08Structs & Pointers3:21 min
- 09Introducing Methods4:28 min
- 10Mutation Methods6:02 min
- 11Using Creation / Constructor Functions4:56 min
- 12Using Constructor Functions For Validation4:52 min
- 13Structs, Packages & Exports5:20 min
- 14Exposing Methods & A Different Constructor Function Name5:38 min
- 15Struct Embedding7:56 min
- 16Structs - A Summary2:57 min
- 17Creating Other Custom Types & Adding Methods5:16 min
- 18Practice Project: Getting User Input7:35 min
- 19Practice Project: Creating a Struct & Constructor Function7:17 min
- 20Practice Project: Adding a Method3:34 min
- 21Practice Project: Handling Long User Input Text6:13 min
- 22Practice Project: Preparing Save To File Functionality4:14 min
- 23Practice Project: Encoding JSON Content5:15 min
- 24Practice Project: Fixes2:13 min
- 25Understanding Struct Tags4:17 min
Interfaces & Generic Code11 lectures44m
- 01Module Introduction0:25 min
- 02Preparing An Interface Use-Case3:36 min
- 03Finishing Interface Preparations3:10 min
- 04Creating a First Interface5:16 min
- 05Using The Interface5:16 min
- 06Embedded Interfaces6:09 min
- 07The Special "Any Value Allowed" Type2:07 min
- 08Working with Type Switches3:36 min
- 09Extracting Type Information From Values5:13 min
- 10Interfaces, Dynamic Types & Limitations3:57 min
- 11Introducing Generics5:31 min
Managing Related Data with Arrays, Slices & Maps17 lectures1h 42m
- 01Introducing Arrays8:02 min
- 02Module Introduction1:19 min
- 03Working with Arrays6:20 min
- 04Selecting Parts of Arrays With Slices3:25 min
- 05More Ways Of Selecting Slices4:29 min
- 06Diving Deeper Into Slices9:41 min
- 07Building Dynamic Lists With Slices9:23 min
- 08Exercise - Problem4:12 min
- 09Exercise - Solution19:59 min
- 10Unpacking List Values3:29 min
- 11Introducing Maps6:42 min
- 12Mutating Maps3:43 min
- 13Maps vs Structs3:59 min
- 14Using The Special "make" Function7:10 min
- 15"make"ing Maps3:08 min
- 16Working with Type Aliases2:33 min
- 17For Loops with Arrays, Slices & Maps5:24 min
Functions: Deep Dive8 lectures57m
- 01Module Introduction1:04 min
- 02Functions as Values & Function Types15:07 min
- 03Returning Functions As Values6:20 min
- 04Introducing Anonymous Functions6:34 min
- 05Understanding Closures6:44 min
- 06Making Sense Of Recursion11:22 min
- 07Using Variadic Functions6:49 min
- 08Splitting Slices Into Parameter Values3:04 min

And 4 more sections in the full course.

Ready to Get Started?

Choose the option that works best for you.

Single Course

Go - The Complete Guide

One Payment. Lifetime Access.

$99one-time

One-time payment
All future updates for this course
Downloadable resources & code
Certificate of completion
Hands-on exercises & projects
Self-paced learning
English captions on all videos
Lifetime access

Buy Go

Single course license

All-Access Membership

Everything we teach. One subscription.

$25/mo

$4,729+ worth of courses

Full access to all courses
All future courses included
Downloadable resources & code
Certificates of completion
Hands-on exercises & projects
Self-paced learning
English captions on all videos
Cancel anytime

Subscribe Now

61 courses included

Go - The Complete Guide

Write core Go code

Use pointers effectively

Model data structures

Build concurrent workflows

Design with interfaces

Handle errors and packages

New Go learners

Working developers

Go refreshers