Web Development with GoLang

You can initialise Go modules, write clean syntax with variables and functions, and run compiled Go binaries locally.

1. Why Go: performance, simplicity and the cloud-native world90 min
   • compiled vs interpreted binaries
   • garbage collection overhead
   • cloud-native tooling ecosystem
2. Installing Go, the toolchain and Go modules120 min
   • go install
   • go.mod and go.sum
   • GOPATH and vendor directory
3. Variables, types and control flow120 min
   • explicit vs inferred typing
   • for loops and switch statements
   • if/else scoping
4. Functions, packages and the standard library120 min
   • multiple return values
   • init functions
   • import aliases
5. Writing and running your first Go programs150 min
   • go run
   • go build
   • cross-compiling targets

Hands-on project: Initialise a Go module for an inventory service, structure packages cleanly under cmd/ and internal/, and write a command-line parser using standard library flags.

You can design custom types with structs and pointers, enforce behavior with interfaces, and handle errors idiomatically.

1. Structs, methods and pointers180 min
   • pointer vs value receivers
   • struct embedding
   • memory alignment basics
2. Interfaces and composition180 min
   • implicit interface satisfaction
   • empty interface interface{}
   • type assertions and type switches
3. Slices, maps and arrays180 min
   • slice underlying arrays
   • make() and cap() allocation
   • map concurrency hazards
4. Error handling the Go way180 min
   • errors.New()
   • fmt.Errorf() with %w
   • errors.Is() and errors.As()
5. Idiomatic Go and project structure180 min
   • Effective Go guidelines
   • standard layout conventions
   • godoc documentation standards

Hands-on project: Refactor a monolithic script into a modular domain package using value and pointer receivers, custom error types, and interface-driven mocking.

You can write safe concurrent pipelines using goroutines, buffered channels, select statements, and the sync package.

1. Goroutines and the Go scheduler120 min
   • M:N scheduler model
   • GOMAXPROCS
   • lightweight stack management
2. Channels and communication120 min
   • unbuffered vs buffered channels
   • sender/receiver synchronization
   • closing channels safely
3. select, sync and the context package120 min
   • select statement mechanics
   • sync.WaitGroup and sync.Mutex
   • context.WithTimeout and cancellation
4. Worker pools and concurrency patterns120 min
   • fan-out fan-in pattern
   • pipeline orchestration
   • rate limiting tokens
5. Detecting and avoiding race conditions120 min
   • go test -race flag
   • atomic package operations
   • deadlock identification

Hands-on project: Build a concurrent log processor that reads thousands of files in parallel using worker pools, bounded channels, and graceful cancellation via the context package.

You can build zero-dependency HTTP servers using the standard library's net/http package, mux routing, and custom middleware.

1. The net/http package and handlers120 min
   • http.Handler interface
   • http.HandleFunc
   • http.Server configuration
2. Routing, requests and responses120 min
   • URL query parameters
   • r.ParseMultipartForm
   • http.ResponseWriter headers
3. Working with JSON120 min
   • encoding/json marshal/unmarshal
   • json struct tags
   • streaming encoders and decoders
4. Middleware fundamentals120 min
   • handler chaining pattern
   • http.HandlerFunc adapters
   • request timing interception
5. Building a server from the standard library120 min
   • signal handling for SIGINT
   • Server.Shutdown() timeouts
   • custom error response envelopes

Hands-on project: Build an HTTP status monitoring server using net/http without third-party frameworks, complete with custom request-logging middleware and graceful shutdown handlers.

You can build high-performance REST APIs using the Gin framework, structured routing, request binding, and validation tags.

1. The Gin framework and routing180 min
   • gin.Default() engine
   • grouping routes with /api/v1
   • path parameter binding
2. Request binding and validation180 min
   • c.ShouldBindJSON()
   • binding struct tags
   • custom validation errors formatting
3. Middleware and error handling180 min
   • Gin middleware stack
   • c.AbortWithStatusJSON()
   • centralized error recovery
4. Structuring a production API180 min
   • handler-service-repository pattern
   • dependency injection of controllers
   • configuration management with Viper
5. Building a complete RESTful service180 min
   • pagination and sorting query params
   • idempotent HTTP methods
   • API versioning strategies

Hands-on project: Build a multi-resource REST API for an e-commerce catalog using Gin, implementing nested route groups, query filters, and payload validation with validator/v10.

You can persist and query relational data using PostgreSQL, raw SQL with database/sql, and ORM mapping with GORM.

1. Relational databases and PostgreSQL120 min
   • psql connection strings
   • pgx driver setup
   • connection pool configuration
2. The database/sql package120 min
   • sql.DB handle lifecycle
   • QueryRow vs Query vs Exec
   • parameterized statements against SQL injection
3. The GORM ORM: models and queries120 min
   • gorm.Model auto-migration
   • CRUD operations
   • hooks and scopes
4. Relationships and migrations120 min
   • belongs-to and has-many associations
   • preload and eager loading
   • schema migration versioning
5. Transactions and performance120 min
   • db.Transaction blocks
   • isolation levels
   • indexing strategies for query performance

Hands-on project: Implement a database layer for an order management system in PostgreSQL, executing raw transactions with database/sql and managing model relationships with GORM.

You can secure backend routes using JWT tokens, bcrypt password hashing, and role-based authorization middleware.

1. Authentication and authorization concepts120 min
   • stateless session tokens
   • claims and signing algorithms
   • cookie vs header transport
2. JWT-based authentication in Go120 min
   • golang-jwt/jwt/v5 package
   • signing tokens with HMAC keys
   • token expiration and verification
3. Password hashing with bcrypt120 min
   • golang.org/x/crypto/bcrypt
   • cost factor tuning
   • timing attack prevention
4. Securing routes with middleware120 min
   • extracting Bearer tokens
   • injecting claims into context
   • unauthorized response handling
5. Sessions and role-based access120 min
   • RBAC permission checkers
   • token revocation patterns
   • secure cookie flags

Hands-on project: Build an authentication service issuing signed JWT access and refresh tokens, paired with bcrypt password storage and role-based access control middleware.

You can write robust unit and integration tests using table-driven patterns, httptest assertions, and benchmark profiling.

1. Go's built-in testing package60 min
   • testing.T assertions
   • go test command flags
   • test coverage reports
2. Table-driven tests60 min
   • struct slice test matrices
   • t.Run() subtests
   • descriptive failure output
3. Testing HTTP handlers with httptest60 min
   • httptest.NewRecorder()
   • net/http/httptest client requests
   • mocking service layers
4. Benchmarks and the race detector60 min
   • testing.B benchmarking loops
   • allocations analysis with -benchmem
   • profiling with pprof
5. Linting, formatting and best practices60 min
   • gofmt and goimports
   • golangci-lint rules
   • staticcheck checks

Hands-on project: Write a test suite for a financial transaction API using Go's testing package, implementing table-driven test cases, HTTP handler mocks, and race-condition checks.

You can build real-time WebSocket channels, manage distributed caching with Redis, and implement rate limiters.

1. WebSockets in Go60 min
   • HTTP to WebSocket upgrade
   • gorilla/websocket connection hub
   • read/write pumps
2. Building real-time features60 min
   • concurrent client broadcast lists
   • heartbeat ping/pong frames
   • connection cleanup on disconnect
3. Redis for caching60 min
   • go-redis client setup
   • cache-aside read patterns
   • TTL expiration strategies
4. Background jobs and queues60 min
   • Asynq task queue package
   • producer-consumer job separation
   • retry policies
5. Rate limiting60 min
   • golang.org/x/time/rate limiter
   • token bucket algorithm
   • Redis sliding window limiter

Hands-on project: Add real-time chat broadcasting to the capstone API using gorilla/websocket, backed by Redis for pub/sub messaging and IP-based rate limiting.

You can build inter-service communication channels using gRPC, Protocol Buffers, and gateway proxies.

1. Monolith versus microservices in Go120 min
   • distributed system trade-offs
   • service boundary definitions
   • network failure handling
2. Designing Go microservices120 min
   • independent code repositories
   • database-per-service pattern
   • health check endpoints
3. gRPC and Protocol Buffers120 min
   • proto3 syntax definitions
   • protoc compiler toolchain
   • streaming RPC types
4. Inter-service communication120 min
   • gRPC client stub generation
   • metadata transmission
   • error translation between gRPC and HTTP
5. API gateway and service patterns120 min
   • reverse proxy routing
   • service discovery concepts
   • distributed tracing headers

Hands-on project: Split an auth module into an independent microservice using gRPC and Protocol Buffers, communicating with the main Gin API gateway over HTTP/2.

You can compile static binaries, package microservices into minimal Docker images, and automate CI/CD pipelines.

1. Building Go binaries60 min
   • CGO_ENABLED=0 static linking
   • stripping debug symbols with -ldflags
   • optimizing binary size
2. Containerising Go with Docker (tiny images)60 min
   • multi-stage builds
   • scratch and alpine base images
   • non-root execution security
3. Environment configuration60 min
   • 12-factor app config
   • envconfig parsing packages
   • secrets management
4. Deploying to the cloud60 min
   • container registry push
   • cloud VM deployment
   • systemd service management for Go
5. CI/CD basics with GitHub Actions60 min
   • automated test workflows
   • linting jobs
   • image build automation

Hands-on project: Containerise a Go microservice using a multi-stage Dockerfile resulting in an image under 30 MB, and deploy it using a GitHub Actions CI/CD pipeline.

You can find a Go service's bottleneck with pprof and operate it safely under load.

1. Profiling a Go service90 min
   • net/http/pprof
   • CPU and heap profiles
   • Reading a flame graph
2. Common Go performance traps90 min
   • Allocation in hot loops
   • Mutex contention
   • Goroutine leaks
3. Structured logging and metrics90 min
   • slog with context
   • Prometheus client metrics
   • Request IDs end to end
4. Operating safely90 min
   • Graceful shutdown
   • Context deadlines
   • Health and readiness endpoints

Hands-on project: Load-test the capstone API to establish a p99 baseline, use pprof to find the allocation or lock causing the hot path, fix it and prove the improvement, then add structured logging, Prometheus metrics and graceful shutdown with request draining.

You can architect, build, test, containerise, and deploy a production-grade Go microservices backend with full interview prep.

1. Plan a production Go backend60 min
   • system architecture specification
   • database schema design
   • API contract documentation
2. Build REST and gRPC services60 min
   • implementing core business logic
   • wiring gRPC client connections
   • integrating middleware stacks
3. Add auth, a database and caching60 min
   • JWT authentication integration
   • GORM repository methods
   • Redis caching layer wiring
4. Containerise, deploy and document60 min
   • Docker Compose orchestration
   • health check verification
   • Postman API test collection
5. Portfolio, GitHub, mock interviews and career prep60 min
   • GitHub repository polish
   • Go concurrency interview Q&A
   • mock technical interviews

Hands-on project: Deliver the capstone system: a production Go backend combining Gin REST endpoints, gRPC microservices, PostgreSQL persistence, Redis caching, JWT auth, and Docker deployment.