Your Learning Journey is Ready!

This learning journey walks you through the primary concepts and hands-on activities required to create an effective local development environment with Kubernetes, which includes everything from the containerization of code to real-time local testing of distributed services.

Skill level

Kubernetes Beginner

Time to complete

18 minutes • 4 lessons

What you'll learn

  • How to create and configure a local dev environment to work with services deployed in Kubernetes
  • Understand Kubernetes basics and cloud-native development concepts
  • How to use Kubernetes for basic app development:
    • Deploy a service from source code to a Kubernetes cluster
    • Route traffic from the cluster’s edge to the app

What you need

Nothing! We’ll walk through learning the concepts and installing the tools you’ll need as we go.

Let's begin! Select your lessons below:

Lesson 1 --> The changing development workflow

2 min • read

Lesson 2 -->The developer experience and the inner dev loop

5 min • read

Lesson 3 --> Making the remote local: Faster feedback, collaboration and debugging

3 min • read

Lesson 4 --> Telepresence quick start

8 min • tutorial

Frequently Asked Questions

Do I need to use a new IDE when developing applications for Kubernetes?

No. Many IDEs offer plugins to add extra Kubernetes support, such as VS Code and IntelliJ IDEA but there is no need to search for a new IDE.

What’s the difference between developing applications for Docker and for Kubernetes?

Building and deploying a Docker container-based application only requires a developer to have Docker installed locally. On the other hand, deploying applications into Kubernetes requires access to a cluster, which can run locally (e.g., minikube, k3s, etc.) or remotely (e.g., GKE, AWS EKS, etc.).Docker Desktop (or Docker for Mac and Windows) now includes the option to install and run a local Kubernetes cluster. Developers that don’t want to install Docker or Kubernetes locally can also develop an application locally (without building a container) and connect and integrate with a remote cluster using a tool like Telepresence.

What’s the best practice for testing Kubernetes-based applications locally?

In addition to software development best practices like unit testing and component testing, for small applications, a simple end-to-end test can be conducted by deploying all of the services that make up an application in a locally running Kubernetes cluster.When a local development machine runs out of CPU or memory to run all the services in a local cluster, using a local-to-remote development tool like Ksync, Skaffold or Telepresence ( can allow integration testing.

How can I develop and test my application when I can’t run all of my applications in a local Kubernetes cluster (minikube, k3s, kind, etc.)?

Using a local-to-remote development tool like Ksync, Skaffold, or Telepresence can enable a fast development loop and integration testing.

Supercharging Your Local Kubernetes Development Environment

Being able to effectively configure a local development environment for services deployed in Kubernetes is not dependent on a single tool or technique. A combination of approaches is required:

Container Build Tools

The ability to quickly and repeatedly build containers locally is vital when changing code and configuration. Many teams want to adopt industry-approved container build standards or don’t want the hassle of assembling their own containers, and here the use of build packs is popular.

Hot Reload

Developers want to quickly see the results of their code changes without having to redeploy or restart all of their services.

K8s-Aware Command Line

When deploying applications via the CLI to multiple K8s environments, both local and remote, it is essential to rapidly understand which context and namespace is being used. Being able to quickly and easily change context and namespaces is also valuable.

Kubernetes Dashboard

Not every developer wants to be at the command line the entire time they are working. Pointing and clicking around a high-level overview of an application’s deployment can support rapid learning and help identify problems such as high CPU or memory consumption.

Collaborative Remote Testing

When building distributed (microservice-based) systems, it is often the case that issues can only be recreated in certain environments. Being able to share access to these environments with both fellow developers and stakeholders enables a quicker find-fix-release dev loop.