High Performance Backend Engineering with Go

About this course

Build and measure a production Go service with safe concurrency, typed database access, REST and gRPC APIs, caching, observability and graceful shutdown.

This is an 8-week specialist track - our most in-depth program, taking you to a professional, hireable standard. Learn online at your own pace. Practice the concepts with the listed assessments.

What's included

• Self-paced lessons and practice (40 estimated hours).
• Hands-on coding quests you solve inside the EchoLens browser compiler - nothing to install.
• Gems, stages and a leaderboard that keep you moving instead of grade anxiety.
• A verified certificate with a scannable QR code, ready to share on LinkedIn, when you satisfy the course requirements.
• Completely free - no fee, just create an account and start.

What you will learn

Course outline - level by level

12 leveles, each with hands-on quests you clear in the portal.

• Level 1. Pointers, Structs and Escape Analysis - Analogy: Loading a truck so the heaviest crates sit over the axles, because where things are placed changes what the vehicle can carry. Covered: Value against pointer semantics, when a struct escapes to the heap, struct field ordering and padding, the cost of copying large values, and reading benchmark allocation output.
• Level 2. Interfaces and Composition - Analogy: A wall socket that accepts any appliance whose plug has the right pins, without knowing what the appliance does. Covered: Implicit interface satisfaction, keeping interfaces small and defining them at the point of use, type assertions and type switches, embedding, and the nil interface trap.
• Level 3. Error Handling, Wrapping and Defer - Analogy: A closing checklist that requires the door to be locked whether the shift ended normally or was cut short. Covered: Explicit error returns, sentinel errors, custom error types, wrapping with percent w, errors.Is and errors.As, defer evaluation order, and the limits of recover.
• Level 4. Goroutines and Channel Communication - Analogy: Couriers passing sealed messages down dedicated tubes instead of everyone writing on the same whiteboard at once. Covered: The scheduler and the cost of a goroutine, buffered against unbuffered channels, directional channel types, closing channels correctly, WaitGroups, and goroutine leaks.
• Level 5. Multiplexing with select and Timeouts - Analogy: A controller listening to four radio channels at once and answering whichever pilot speaks first. Covered: select semantics and random choice among ready cases, the default clause for non blocking reads, time.After and time.NewTimer, and why an abandoned timer can hold memory.
• Level 6. Synchronisation Primitives and Context - Analogy: A signal box coordinating trains, plus a central order that stops every departure at once when the weather turns. Covered: Mutex and RWMutex, atomic operations, sync.Once, the race detector, context cancellation and deadlines, and passing context through call chains.
• Level 7. REST Services with net/http and chi - Analogy: A service window that takes the order, records it and hands back a receipt with a code the customer can quote later. Covered: Routing with chi, middleware chains for logging, recovery and request identifiers, JSON encoding and decoding, request scoped context, timeouts on the server, and consistent error envelopes.
• Level 8. Connection Pooling with pgx - Analogy: A shared pool of delivery vans that drivers take and return, instead of buying a new van for every parcel. Covered: pgxpool configuration, maximum and minimum connections, connection lifetime and health checks, parameterised queries and why string concatenation is an injection risk, and scanning rows safely.
• Level 9. Type Safe Queries with sqlc and Transactions - Analogy: An accountant posting both sides of a transfer with one signature, so the ledger is never half written. Covered: Writing SQL first and generating Go from it with sqlc, migrations with goose or migrate, transactions in Go, and choosing an isolation level. Transaction theory is covered in depth in Course 6.
• Level 10. Protocol Buffers and gRPC - Analogy: A dedicated telegraph line carrying dense agreed shorthand between two stations, rather than posting a letter each time. Covered: Proto3 schema definition, code generation with protoc, unary and streaming calls, interceptors, deadlines and cancellation, status codes, and schema evolution without breaking clients.
• Level 11. Caching with Redis - Analogy: Keeping the ten most ordered dishes plated on the pass, and knowing exactly when to throw them away. Covered: The cache aside pattern, key design, TTL selection, invalidation on write, stampede protection with single flight, and deciding what should never be cached.
• Level 12. Structured Logging, Graceful Shutdown and Load Testing - Analogy: A captain who closes the bulkheads and berths the ship before cutting the engines, rather than stopping mid channel. Covered: Structured JSON logging with slog, log levels and sampling, never logging secrets, intercepting SIGTERM, draining in flight requests, closing pools in order, and reading a load test report.

Who it's for

High Performance Backend Engineering with Go suits learners at a intermediate to advanced level who want a practical, project-based route into High Performance Backend Engineering with Go. You need only a browser and an internet connection - all coding runs inside the EchoLens compiler, so there is nothing to set up.

Certificate

Pass every required assessment at its stated threshold to earn your verified certificate. Optional practice and watching videos do not determine eligibility. Anyone can scan its QR code to verify it on our site. You can add it to your CV or share it to LinkedIn in one click.