Learn to build Go systems with AI agents September 16 & 17 Enroll Now
Ardan Labs home
Contact Us
Ardan Labs Logo

Let's Talk

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.
Ardan Labs

Ultimate Go Bundle

110+ Hours Beginner - Advanced

Purchase of this bundle gives you access to all of our existing and future Go courses durring your membership year (12 month membership).

Free Preview
Ultimate Go Bundle | Ardan Labs

What You'll Learn

This is a comprehensive and advanced training for the engineer who wants to learn the skills needed to build production-level applications in Go. You will be challenged to think about what you’re doing and why, with a focus on making you a better engineer.

Requirements

You don't need to have prior experience with Go. However, it is helpful to be familiar with basic programming concepts (i.e structural vs object oriented programming, command line, etc..).

Detailed Course Info
  • Skill Level: Beginner - Advanced
  • Bundle Length: 110+ Hrs

Note: All of our bundles are for a one year subscription to the course content. This includes all updates and new content added during that time.

Team Pricing: We offer special pricing models for teams

Courses Included in the Bundle

Practical Go Foundations Icon

18+ total hours

Intermediate

Practical Go Foundations

This introductory course explores topics like strings, REST APIs, error handling, testing, sorting, and more! Perfect for engineers just starting their journey into Go.

with: Miki Tebeka

View Course Info

Course Introduction

This course will help you become familiar with the basic concepts of the Go programming language. Through lectures and coding exercises, you’ll learn about the core concepts needed to become a productive Go developer.

This course is part of the Ultimate Go Track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Requirements:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

  • A basic understanding of the Go programming language.
  • Some experience with the Go Tour is recommended.

You should have the following installed on your computer prior to the workshop:

  • Go SDK from golang.org/dl/
  • An IDE, either VSCode with Go extension or GoLand
  • Git

Course Outline

Module 1 - Introduction & Setup
  • 1.1 - Introduction to Go
  • 1.2 - Setting Up So You Can Get Started
  • 1.3 - Writing Your First Go Program, Compiling & Running It
Module 2 - Data Structures & REST APIs
  • 2.1 - Understanding Strings in Go, Formatted Output
  • 2.2 - Calling REST APIs, HTTP Requests, JSON
  • 2.3 - Working with Files, Using Defer to Manage Resources, Error Handling
  • 2.4 - Composing io.Reader and io.Writer
  • 2.5 - Working with Slices, Slices Internals
Module 3 - Structures, Methods, & Interfaces
  • 3.1 - Defining & Creating Structs
  • 3.2 - Adding Methods to Structs
  • 3.3 - Creating and Implementing Interfaces
  • 3.4 - The Empty Interface
  • 3.5 - Using Generics
Module 4 - Panics & Maps
  • 4.1 - Handling Panics
  • 4.2 - Calculating Word Frequency, Working with Maps
Module 5 - Concurrency
  • 5.1 - Overview of Concurrency in Go
  • 5.2 - Using goroutines and Channels
  • 5.3 - Iterating Over Channels, Closing Channels
  • 5.4 - Using the Fan-Out Pattern
  • 5.5 - Exercise: Converting Sequential Algorithms to Concurrent
  • 5.6 - Using the Sync Package
  • 5.7 - Using the Select, Working with Multiple Channels, Timeouts and Cancellations
  • 5.8 - Exercise: Real-Time Bidding, Adding Timeouts
Module 6 - Project Engineering
  • 6.1 - Documenting Your Code
  • 6.2 - Testing Your Code
  • 6.3 - Dependency Management, go mod
  • 6.4 - Using the Testify Library
  • 6.5 - Exercise: Reading Test Cases from a TOML File
  • 6.6 - Fuzz Testing
  • 6.7 - Installing and Linters, the “go tool” Command
  • 6.8 - Project Structure, Splitting to Sub-Packages
  • 6.9 - Writing an HTTP Server
  • 6.10 - Testing HTTP Request Handlers
  • 6.11 - Adding Logging and Metrics
  • 6.12 - Configuring Your Server: Environment Variables, Flags, Configuration Files
Ultimate Go: Language Guide Icon

20+ total hours

Intermediate

Ultimate Go: Language Guide

The Ultimate Go: Language Guide is for developers with some experience with Go trying to dig deeper into the language with a focus on performance. They want to learn internals and make better engineering decisions.

with: Bill Kennedy

View Course Info

Course Introduction

Learn to write better, more idiomatic and performant code in Go with a focus on micro-level engineering decisions. The course begins with a focus on Go internals that are critical to understanding the core tradeoffs on readability, simplicity and performance.

You will learn about data semantics, guidelines, mechanical sympathy, data oriented design, package oriented design, and how to structure your Go projects for the long term.

This course is part of the Ultimate Go Track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Requirements:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

  • Studied CS in school or has a minimum of two years of experience programming full-time professionally.
  • Familiar with structural and object-oriented programming styles.
  • Has worked with arrays, lists, queues and stacks.
  • Understands processes, threads and synchronization at a high level.

Operating Systems:

  • Has worked with a command shell.
  • Knows how to maneuver around the file system.
  • Understands what environment variables are.

You should have the following installed on your computer prior to the workshop:

  • Go SDK from golang.org/dl/
  • An IDE, either VSCode with Go extension or GoLand
  • Git

Course Outline

Strings & Formatted Output:
  • 1.1 - Prepare Your Mind - ( 17:38 )
  • 1.2 - Productivity vs. Performance - ( 06:24 )
  • 1.3 - Correctness vs. Performance - ( 07:14 )
  • 1.4 - Code Reviews - ( 19:16 )
  • 1.5 - If Performance Matters - ( 03:31 )
Memory & Data Semantics:
  • 2.1 - Variables - (05:04)
  • 2.2 - Struct Types - (22:55)
  • 2.3.1 - Pointers (Pass by Values) - (17:43)
  • 2.3.2 - Pointers (Sharing Data) - (07:50)
  • 2.3.3 - Pointers ( Escape Analysis) - (19:46)
  • 2.4 - Constants - (23:50)
Data Structures:<
  • 3.2.1 - Arrays (Mechanical Sympathy) - (15:00)
  • 3.2.1 - Arrays (Semantics) - (11:10)
  • 3.2.1 - Arrays (Range Mechanics) - (06:39)
  • 3.3.1 - Slices (Declare, Length & Reference Types) - (10:00)
  • 3.3.2 - Slices (Appending Slices) - (03:00)
  • 3.3.3 - Slices (Taking Slices of Slices) - (03:00)
  • 3.3.4 - Slices (Slices & References) - (05:35)
  • 3.3.5 - Slices (Strings & Slices) - (10:23)
  • 3.3.6 - Slices (Range Mechanics) - (04:15)
  • 3.4 - Maps - (11:23)
Decoupling:
  • 4.1.1 - Methods (Value & Pointer Semantics) - (16:37)
  • 4.1.2 - Methods (Function/Method Variables) - (14:43)
  • 4.2.1 - Interfaces (Polymorphism) - (18:19)
  • 4.2.2 - Interfaces (Method Sets & Address of Value) - (13:42)
  • 4.3 - Embedding - (09:50)
  • 4.4 - Exporting - (09:52)
Composition:
  • 5.1 - Grouping Types - (15:21)
  • 5.2.1 - Decoupling Part 1 - (37:02)
  • 5.3.2 - Conversion & Assertions - (04:49)
  • 5.4 - Interface Pollution - (08:51)
  • 5.5 - Mocking - (08:15)
Error Handling:
  • 6.1 - Default Error Values - (05:51)
  • 6.2 - Error Variables - (10:52)
  • 6.3 - Types as Context - (06:59)
  • 6.4 - Behavior as Context - (08:14)
  • 6.5 - Find the Bug - (04:19)
  • 6.6 - Wrapping Errors - (10:16)
Packaging:
  • 7.1 - Language Mechanics & Design Guidelines - (11:15)
  • 7.2 - Package-Oriented Design - (15:50)
Go Routines:
  • 8.1 - OS Scheduler Mechanics - (33:00)
  • 8.2 - Go Scheduler Mechanics - (27:11)
  • 8.3 - Creating Go Routines - (19:37)
Data Races:
  • 9.1 - Managing Data Races (22:15)
Channels:
  • 10.1 - Signaling Semantics - (11:08)
  • 10.2 - Basic Patterns - (06:21)
  • 10.3 - Fan Out - (05:28)
  • 10.4 - Wait for Task - (02:31)
  • 10.5 - Pooling - (05:14)
  • 10.6 - Fan Out Semaphore - (05:22)
  • 10.7 - Fan Out Bounded - (06:14)
  • 10.8 - Drop Pattern - (05:06)
  • 10.9 - Cancellation Pattern - (07:28)
Concurrency Patterns:
  • 11.1 - Failure Detection (18:30)
Testing:
  • 12.2 - Table Unit Testing - (04:10)
  • 12.3 - Mocking Web Server Response - (07:21)
  • 12.4 - Testing Internal Endpoints - (09:01)
  • 12.5 - Sub Tests - (05:40)
  • 12.6 - Code Coverage - (03:33)
Benchmarks:
  • 13.1 - Basic Benchmarking - (09:24)
  • 13.2 - Validate Benchmarking - (07:01)
  • 13.3 - CPU-Bound Benchmarking - (07:03)
  • 13.4 - IO-Bound Benchmarking - (06:05)
Profiling & Tracing:
  • 14.1 - Profiling Guidelines - (05:42)
  • 14.2 - Stack Traces - (08:28)
  • 14.3 - Micro Level Optimization - (28:20)
  • 14.4 - Macro Level Optimization - (24:47)
  • 14.5 - Execution Tracing - (38:56)
Ultimate Go: Software Design with Kubernetes Icon

25+ total hours

Intermediate

Ultimate Go: Software Design with Kubernetes

This course teaches you how to build production-level services in Go, leveraging the power of a Domain Driven, Data Oriented Architecture deployed in Kubernetes.

with: Bill Kennedy

View Course Info

Course Introduction

From the beginning of the course, you will pair-program with your instructor Bill Kennedy as he walks you through the design philosophies, architectural decisions, and best practices as they apply to engineering a production-ready Go service.

With each new feature that is added to the service, you will learn how to deploy and manage the Kubernetes environment used to run the service. Throughout the class, the code being worked on is pushed to a repository for personal access and review.

This course is part of the Ultimate Go Track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Requirements:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

  • Studied CS in school or has a minimum of two years of experience programming full time professionally.
  • Familiar with structural and object-oriented programming styles.
  • Has worked with arrays, lists, queues and stacks.
  • Understands processes, threads and synchronization at a high level.

Operating Systems:

  • Has worked with a command shell.
  • Knows how to maneuver around the file system.
  • Understands what environment variables are.

You should have the following installed on your computer prior to the workshop:

  • Go SDK from golang.org/dl/
  • An IDE, either VSCode with Go extension or GoLand
  • Git

Course Outline

Introduction:

Introduction to the class and all the engineering that you will learn.

  • 1.1: Design Philosophy, Guidelines, What to Expect
  • 1.2: Tooling and Images to Install
Deploy First Mentality:

We begin to build the service with a focus on the ability to deploy the service in Kubernetes.

  • 2.1: Project Layers, Policies, and Guidelines
  • 2.2: Prepare Project
  • 2.3: Build Service with Logging
Kubernetes:

We introduce Kubernetes and get a K8s environment up and running. At this point, everything we do runs in the K8s environment.

  • 3.1: Clusters, Nodes and Pods
  • 3.2: Start the Kubernetes Cluster
  • 3.3: Create/Build Dockerfile for the Service
  • 3.4: Create/Apply K8s Deployment for the Service
Kubernetes Quotas:

We introduce applying Quotas to the deployment and discuss the problems that can result.

  • 4.1: Understanding the Go Scheduler
  • 4.2: Understanding CPU Quotas
  • 4.3: Adding Quotas and Adjusting GOMAXPROCS
Finish Initial Service Startup/Shutdown:

We finish the initial startup and shutdown of the service.

  • 5.1: Configuration
  • 5.2: Debugging / Metrics
  • 5.3: Shutdown Signaling and Load Shedding
Web Framework:

We build out our own router by extending an existing one. This gives us a framework for injecting business logic into the processing of requests. It also allows for more consistency in the handling of requests.

  • 6.1: Basic Structure of an HTTP Router
  • 6.2: Liveness and Readiness Handlers
  • 6.3: Customize the Router
  • 6.4: Middleware Support
  • 6.5: Sending Responses
Middleware:

We add middleware functions for business-level logic that needs to be injected into the processing of requests.

  • 7.1: Logging
  • 7.2: Error Handling
    • Understanding What Error Handling Means
    • Declaring Custom Error Types
    • Consistent Handling and Response
  • 7.3: Panic Handling
  • 7.4: Metrics
JSON Web Tokens (JWT):

We gain an understanding of how JWT's work and their shortcomings. We also learn about OPA and how we will use it to perform the actual authentication and authorization.

  • 8.1: Understanding JWT
  • 8.2: Private/Public Key Generation
  • 8.3: Token Generation
  • 8.4: Token Signature Validation with OPA
Key Store:

We create a simple key store for the project to store and retrieve the private key.

  • 9.1: Key Store Package
Authentication / Authorization:

We integrate authentication and authorization support into the project by developing a package to generate and validate tokens. Then we integrate the packages into the application and test that things are working.

  • 10.1: Auth Package
  • 10.2: Auth Unit Test
  • 10.3: Add Middleware
  • 10.4: Auth Service
  • 10.5: Auth Client
Domain Driven, Data-Oriented Architecture:

We talk about the data-driven data oriented architecture that is implemented in the project. We discuss the design philosophy, guidelines, and semantics of how the three layers of App, Business, and Storage work together.

  • 11.1: Architecture Review
  • 11.2: Data Flow Trust vs Non-Trust
Database Support:

We add a Postgres database to our K8s environment. Then we write a small database package that provides more effective support for using the SQLx package. Finally, integrate the database package on application startup.

  • 12.1: Kubernetes Support for Postgres
  • 12.2: Create Database Package
  • 12.3: Update Readiness Handler to Perform DB Checks
Database Migrations and Seeding:

We define our schema and provide support for migration schema changes over time. We also provide support for seeding the database. Finally, we added support in Kubernetes to run the migration and seeding on POD startup.

  • 13.1: Maintaining Database Schemas and Seeds
  • 13.2: Admin Tooling and Init Containers to Automate Migrations
API, App, Business, and Storage Implementation:

We implement the Create domain inside the App, Business, and Storage layers.

  • 14.1: User Business Domain Support
  • 14.2: User Storage Domain Support
  • 14.3: User App Domain Support
  • 14.4: User API Domain Support
Testing:

We add docker and unit testing support for writing tests against a real database and write the actual user package tests.

  • 15.1: Starting and Stopping Containers
  • 15.2: Database Testing Support
  • 15.3: Unit and API Testing Support
  • 15.4: Write User Business Test
  • 15.5: Write User API Tests
Delegate and Transactions:

We talk about how the delegate and transaction systems work.

  • 16.1: Delegate System
  • 16.2: Transaction System
Observability:

We add tracing to the project by integrating Open Telemetry and Zipkin.

  • 17.1: Integrate OTEL into the Project
Review Service Project:

Review service project and get it running.

  • 18.1: Check For Dependency Upgrades, Rebuild, Run
Ultimate Go: Advanced Engineering Icon

20+ total hours

Intermediate

Ultimate Go: Advanced Engineering

Learn advanced Go concepts by building a reference implementation of a blockchain in Go! The goal of this class is to share how to code complex engineering tasks required to build blockchain technology.

with: Bill Kennedy

View Course Info

Course Introduction

From the beginning, you will pair program with the instructor, walking through the design philosophies and guidelines used to engineer the code. Throughout the class, you will learn more about Go and the advanced engineering features of the language.

This course is part of the Ultimate Go Track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Requirements:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

  • An intermediate understanding of the Go programming language is recommended.
  • Students will derive the most value if they have taken our Ultimate Go: Language Guide and Ultimate Go: Software Design with Kubernetes classes.

You should have the following installed on your computer prior to the workshop:

Course Outline

Introduction:
  • 1.1: Design Philosophy, Guidelines, What to Expect
  • 1.2: Tooling to Install
  • 1.3: Initial Code for the Project
Blockchain Fundamentals:
  • 2.1: Blockchain Fundamentals
  • 2.2: Genesis
  • 2.3: Transactions and Blocks
  • 2.4: Digital Signatures
  • 2.5: Account Management
  • 2.6: Memory Pooling
  • 2.7: Mining and Consensus
  • 2.8: Fraud Detection
Genesis:
  • 3.1: What is Genesis
  • 3.2: Configuration Options
  • 3.3: Reading From Disk
Digital Signatures:
  • 4.1: What is a Digital Signature
  • 4.2: Hashing
  • 4.3: Stamping
  • 4.4: Signing
  • 4.5: Addressing
  • 4.6: Verification
Database:
  • 5.1: What is Inside the Blockchain Database
  • 5.2: Transaction Types
  • 5.3: Accounting
  • 5.4: Block Types
Cryptographic Audit Trails:
  • 6.1: What is a Cryptographic Audit Trail
  • 6.2: Chaining
  • 6.3: Merkle Tree Proofs
  • 6.4: Account Database Proof
Memory Pools:
  • 7.1: What is a Mempool
  • 7.2: Storing Transactions
  • 7.3: Transaction Selection
Accepting Signed Transations:
  • 8.1: Handler function
  • 8.2: Transaction Signature Verification
  • 8.3: Mempool Inclusion
Mining:
  • 9.1: What is Consensus and Mining
  • 9.2: Proof Of Work Algorithm
  • 9.3: Implement Mining Workflow
Storage:
  • 10.1: Storage Options
  • 10.2: Writing Blocks
  • 10.3: Reading and Searching Blocks
Peer to Peer Networks:
  • 11.1: What is the P2P Network
  • 11.2: Peer Discovery
  • 11.3: Sharing Transactions
  • 11.4: Sharing Blocks
Wallets:
  • 12.1: Chrome Plugin Basics
  • 12.2: Javascript Support
  • 12.3: Send Signed Transaction
Ultimate Debugging Icon

16+ total hours

Beginner

Intermediate

Ultimate Debugging

Learn the latest tips, tricks, and best practices around debugging in Golang.

with: Derek Parker

View Course Info

Course Introduction

This course is designed for developers who want to become proficient debugging Go software using the Delve debugger. Whether you’ve never used a debugger in your life or are a Delve expert, everybody will walk away with new information that can be used in their day to day development workflow.

The course will initially focus on Delve, which is the de facto Go debugger. We will start with the basics and move into more advanced use cases over the 5 days. On the last day of class, we will dig into new tools and cover profiling / perf tools, how to use them effectively, and how to interpret the data for root cause analysis.

At the end of the subscription period, your membership does not automatically renew.

Requirements:

A basic understanding of the Go programming language. Students do not have to be expert Go users, but they will get the most from the workshop if they have completed the majority of the [Go Tour] (https://tour.golang.org/).

Course Outline

Day 1:
  • Introduction, getting started, navigating your program, inspecting program state, changing program state.
Day 2:
  • Advanced program navigation, tracing your program, examining core dumps (post-mortem debugging). Part 1
Day 3:
  • Advanced program navigation, tracing your program, examining core dumps (post-mortem debugging). Part 2
Day 4:
  • Scripting Delve, remote debugging, using the JSON-RPC API, record and replay debugging.
Day 5:
  • Debugging containerized applications, debugging an application on Kubernetes. Part 1
Day 6:
  • Debugging containerized applications, debugging an application on Kubernetes. Part2
Day 7:
  • Using proof profiling tools, using perf on Go binaries, and deep dive into Delve and Go internals. Part 1
Day 8:
  • Using proof profiling tools, using perf on Go binaries, and deep dive into Delve and Go internals. Part 2
Writing Secure Go Code Icon

1+ total hours

Intermediate

Writing Secure Go Code

This course covers best practices for securing your Go applications. You’ll work with a simple Go app & identify security vulnerabilities from the OWASP Top Ten.

with: Miki Tebeka

View Course Info

Course Introduction

Follow along with the instructor as he overviews common vulnerabilities in a live Go application. You’ll learn about tools and strategies to help you identify security vulnerabilities and how to think about security when it comes to your Golang application.

This course is part of the Ultimate Go Track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Requirements:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

  • Studied CS in school or has a minimum of two years of experience programming full time professionally.
  • Familiar with structural and object-oriented programming styles.
  • Has worked with arrays, lists, queues and stacks.
  • Understands processes, threads and synchronization at a high level.

You should have the following installed on your computer prior to the workshop:

  • Go SDK from golang.org/dl/
  • An IDE, either VSCode with Go extension or GoLand
  • Git

Course Outline

What's Covered:
  • The Security Mindset - (03:00)
  • Go Security Policy - (04:43)
  • OWASP Top Ten - (06:46)
  • Input - (09:10)
  • Output - (17:46)
  • Authentication - (25:56)
  • Infrastructure - (28:42)
Ultimate Go: Notebook Icon

PDF & Paperback

Ultimate Go: Notebook

The ultimate companion to the Ultimate Go: Language Guide course. Help turn your programming to engineering with this notebook.

with: Bill Kennedy

View Course Info

About This Book

This notebook has been written and designed to provide a reference to everything covered in our Ultimate Go class. If you have taken the class before, this notebook will be invaluable for reminders on the content. If you have never taken the class, there is still tremendous value in this book. It covers more advanced topics not found in other books today.

  • Guidelines, design philosophy, white-boarding, and notes shared from the Ultimate Go training.
  • Learn advanced concepts in Go from types to profiling.
  • Get started with generic functions and types.

View the full details

Why Engineers & Teams Trust Ardan Labs

Extremely well organized and high value

The course is extremely well organized and the pace is also very conducive to the learning process. The exercises are very well organized. Delivered very high value.
Cisco

Cisco

Best training in the Go community

You should reach out to the team over at Ardan Labs. They have been training the Go community since the beginning and I've yet to see anyone do it better.
Kelsey Hightower

Kelsey Hightower

Go features that made work better

Feeling so happy with myself: yesterday at work I refactored some code to use Go 1.16 built-in embed. I learned about it at an Ardan Labs service class.
Jessica Greene

Jessica Greene

Well-structured and useful advice

Excellent class. The instructor is a hacker speaking to hackers, so we got very useful information and advice. Well-structured and paced. 10/10 would gopher it again.
ZipRecruiter

ZipRecruiter

Best ever — learned to build great services

I finished Ultimate Service from Ardan Labs. I'm telling you this was the best ever. Talking from project structures to metrics. Now I can write good services in Go.
Adeniyi Oluwatola

Adeniyi Oluwatola

Improved productivity with Go

Thanks Ardan Labs for a great Ultimate Go class! Bill is a great teacher and I'm definitely more productive in Go now.
Steve Francia

Steve Francia

Complex topics explained clearly

Highly recommend Ultimate Go by Bill Kennedy and Ardan Labs. I appreciate how Bill explains complex topics simply and clearly. The labs were incredibly helpful too.
Matt Holt

Matt Holt

Well documented and well structured

Their quality is astounding. They went above and beyond what we asked, working in line with best practices. Everything had test cases, was well documented and well structured, and ran smoothly.
Cole Calistra

Cole Calistra

The perfect partner

ArdanLabs was the perfect partner for us because there is no better Go training out there and their engineer augmentation services didn't feel like engaging with contractors. Their engineers are true team players and great mentors for our team.
Tradesy

Tradesy

Great class!

Great class! Our teams benefited from post-class help in code reviews, mentoring, and development of starter kits for typical applications types in our environment.
PayPal

PayPal

Commitment to quality

The folks at Ardan Labs undertook all the tasks around software delivery (continuous integration, continuous delivery, unit testing, documentation, system integration) with the same commitment to quality that they demonstrated towards their code.
Carnegie Technologies

Carnegie Technologies

Absolutely professional delivery

Absolutely professional delivery of content. Engaging, to the point, great exercises, and very well rehearsed. You can tell Miki Tebeka is passionate about what he does.

GoodRx

See What's New

From the Lab

Where ideas get tested and shared. From the Lab is your inside look at the tools, thinking, and tech powering our work in Go, Rust, and Kubernetes. Discover our technical blogs, engineering insights, and YouTube videos created to support the developer community.

Explore our content:

Content hub Blog News YouTube
01 / 03

Leverage our experience. Get what you need.