Skip to content

Courses / On-demand courses

On demandRecorded by an instructor, graded by Nova

Kubernetes from Zero

Containers to a running cluster: deploy, scale and fix real applications on Kubernetes.

Kubernetes from Zero is a self-paced online course: 10 hours of recorded sessions across 7 modules, with 6 graded by Nova, Square 1's AI tutor. The founding price is A$45, down from A$90. Start any time and keep your own pace.

Price: A$45A$9050% off

Founding price for the first cohort, until 21 October.

Founding price, one payment. Founding students keep their founding price on any second programme.

Founding intake

Spot holders hear the start date first.

Reserve your spot

Three fields hold it. A few short questions after that.

No account, no card. Holding a spot is free, and you confirm before anything is charged. We use these details to place you, never to sell.

Get the course booklet

Kubernetes from Zero. PDF, 11 pages, 241 KB. Tell us who you are and it downloads straight away.

You are a

No account, no card. We email you a copy and may contact you about this course. We never sell your details. Privacy

Module by module

  1. Module 1 · 90 min · graded

    Containers first: images that behave

  2. Module 2 · 60 min · graded

    Your first cluster and kubectl

  3. Module 3 · 90 min · graded

    Deployments, services and ingress

  4. Module 4 · 90 min · graded

    Config, secrets and storage

  5. Module 5 · 90 min · graded

    Health checks, scaling and rollouts

  6. Module 6 · 60 min

    Debugging a broken cluster

  7. Module 7 · 120 min · graded

    Project: a three-service app on managed Kubernetes

recorded hours
10
modules, in order
7
deployed projects
3
graded checkpoints
6

Who it is for, and what you receive.

Developers and IT people who can use a terminal and want to deploy, scale and debug real applications on Kubernetes, from a container image to a managed cluster.

Before you start

You can use a terminal and have built a small web app in any language.

Skills

  • Docker
  • Kubernetes
  • kubectl
  • Helm
  • ingress
  • rollouts
  1. 1

    The recorded sessions

    Taught by an instructor, taken in order at your own pace, yours for twelve months.

  2. 2

    Graded work after every module

    Exercises and projects marked by Nova against a rubric you can read, with what you did well and what to fix.

  3. 3

    The projects

    Deployed and graded, each one on your record with its repository.

  4. 4

    Your hiring plan

    The same six-part plan the bootcamps use, run with the career agent.

  5. 5

    The record and the certificate

    Every grade at square1ai.com/u/{handle}; a credential ID that resolves at square1ai.com/verify.

  6. 6

    Nova as your tutor

    Help that is about your actual work, because it has read all of it.

The content plan, module by module.

10 recorded hours from an instructor, taken in order at your own pace. Nova grades the work at the end of each module.

  1. Containers first: images that behave

    Module 1 · 90 min

    Graded at the end: A small, secure image for a real app.

    • Docker
    • Kubernetes
    • GitHub

    Dockerfiles that stay small

    Layers and caching

    Scanning an image

  2. Your first cluster and kubectl

    Module 2 · 60 min

    Graded at the end: An app running on a local cluster.

    • Docker
    • Kubernetes
    • GitHub

    A local cluster

    Pods, namespaces and labels

    kubectl you use daily

  3. Deployments, services and ingress

    Module 3 · 90 min

    Graded at the end: A web app reachable through ingress.

    • Docker
    • Kubernetes
    • GitHub

    Deployments and replica sets

    Services and DNS

    Ingress and TLS

  4. Config, secrets and storage

    Module 4 · 90 min

    Graded at the end: A stateful app with secrets kept out of the image.

    • Docker
    • Kubernetes
    • GitHub

    ConfigMaps and secrets

    Volumes and claims

    Stateful sets

  5. Health checks, scaling and rollouts

    Module 5 · 90 min

    Graded at the end: A zero-downtime rollout and a rollback.

    • Docker
    • Kubernetes
    • GitHub

    Probes

    Horizontal autoscaling

    Rollouts and rollbacks

    Helm charts

  6. Debugging a broken cluster

    Module 6 · 60 min

    Watch and take notes; nothing to submit in this module.

    • Docker
    • Kubernetes
    • GitHub

    CrashLoopBackOff and friends

    Events and logs

    A debugging checklist

  7. Project: a three-service app on managed Kubernetes

    Module 7 · 120 min

    Graded at the end: The app deployed on a managed cluster, with its runbook.

    • Kubernetes
    • Docker
    • GitHub

    The app

    The cluster

    The deploy

    The runbook

The projects.

Each is deployed and graded by Nova against a rubric you can read before you start.

  1. 1

    A containerised app

    Take a small web app, yours or an open-source one, and containerise it with an image that is as small as you can make it and passes a vulnerability scan. Run it locally and on a local cluster.

    You hand in

    • Dockerfile
    • Image scan report
    • Cluster manifests
    • Notes on image size

    The rubric requires

    The image runs on the cluster and the scan shows no critical findings.

  2. 2

    A stateful app

    Deploy an app with a database on a cluster. Configuration lives in ConfigMaps, credentials in secrets, never in the image, and data survives a pod being deleted.

    You hand in

    • Manifests or a Helm chart
    • Secrets handling notes
    • Proof data survives a pod restart

    The rubric requires

    Deleting the database pod loses no data and no secret appears in the image or repository.

  3. 3

    A three-service app on a managed cluster

    Deploy a three-service application to a managed cluster on AWS, Azure or Google Cloud with ingress, health checks, autoscaling and a rolling update, and write the runbook a teammate would use at 2 a.m.

    You hand in

    • Repository with manifests
    • Public URL
    • Rollout and rollback demonstration
    • Runbook

    The rubric requires

    A release rolls out with no downtime and a rollback restores the previous version.

What you can do at the end.

Applications you have deployed, scaled and fixed on Kubernetes, and three graded projects on your record that show it.

  1. 1

    Build small, secure container images and run them locally.

  2. 2

    Run applications on a cluster with deployments, services and ingress.

  3. 3

    Keep configuration and secrets out of images and give apps persistent storage.

  4. 4

    Use health checks, autoscaling and rollouts, and roll back a bad release.

  5. 5

    Find and fix the usual reasons a workload will not start.

  6. 6

    Deploy a multi-service application to a managed cluster with a runbook.

Roles this prepares you for

  • Cloud engineer
  • DevOps engineer
  • Platform engineer

No placement rate is shown, because there are no graduates to count yet. The roles above are what the projects are built for.

Your record at the end.

Every exercise and project is graded by Nova against a rubric you can read, and every grade is kept on one page an employer can open and run. This is what the programme writes to it.

Graded, line by line
Nova reads every submission against the brief and the rubric and returns a score, what you did well and what to fix.
Module by module
Each module ends in graded work; the next opens when you are ready, on your own schedule.
Nova remembers
Help is about your actual work, because the tutor has every submission and every failed exercise of yours.
One page an employer can run
Every grade and project at /verify. An employer opens it and runs the code.

Record, Kubernetes from Zero

Example

  1. Project

    A containerised app

    The image runs on the cluster and the scan shows no critical findings.

    Graded
  2. Project

    A stateful app

    Deleting the database pod loses no data and no secret appears in the image or repository.

    Graded
  3. Project

    A three-service app on a managed cluster

    A release rolls out with no downtime and a rollback restores the previous version.

    Graded
  4. Every module

    6 graded checkpoints

    Each module ends in work Nova grades line by line against a rubric you can read.

    Graded
  1. After

    Your hiring plan

    Target roles, the gap map, the proof to send, weekly actions and an interview log.

    Kept

The entries, not the grades: those are yours to earn. The page lives at /verify and an employer needs no account to open it.

5 entries, at your own pace. 25 spots are open.

Reserve my spot

How we help you find a job.

Proof, not a certificate: the projects you deployed are the thing you show, and the tools below are yours to use.

  1. 1

    Your hiring plan

    The same six-part plan the bootcamps use: target roles, the gap map, the proof to send, weekly actions, an interview log, the outcome. You run it with the career agent.

  2. 2

    A record an employer can run

    Your graded projects on /verify. An employer opens it and runs the code.

  3. 3

    The career agent

    Paste a real job posting at /career and it maps the role to your graded work and what to do next.

  4. 4

    The roles directory

    Every role we prepare people for, what it pays and what it asks, at /roles.

  5. 5

    A path to the live cohort

    If you want the instructor, the gates and the hiring sprint, the bootcamp on the same subject is one waitlist away.

Get the course booklet

Kubernetes from Zero. PDF, 11 pages, 241 KB. Tell us who you are and it downloads straight away.

You are a

No account, no card. We email you a copy and may contact you about this course. We never sell your details. Privacy

Questions people ask.

About Kubernetes from Zero, answered from the plan on this page.

Related programmes

How long is Kubernetes from Zero?

10 hours of recorded sessions across 7 modules, taken at your own pace. 6 of the modules end in work Nova grades.

Is Kubernetes from Zero live or self-paced?

Self-paced. The sessions are recorded by an instructor who does this work, and Nova, Square 1's AI tutor, grades every checkpoint and project against a rubric you can read.

How much does Kubernetes from Zero cost?

A$45 for the founding intake, paid once; the standard price is A$90. It is the same price in every country. Founding students keep their founding price on any second programme.

Who is Kubernetes from Zero for?

Developers and IT people who can use a terminal and want to deploy, scale and debug real applications on Kubernetes, from a container image to a managed cluster. Before you start: You can use a terminal and have built a small web app in any language.

What will I build in Kubernetes from Zero?

3 deployed projects: A containerised app, A stateful app and A three-service app on a managed cluster. Each is graded against a published rubric and kept on a record an employer can open at /verify.

What skills does Kubernetes from Zero teach?

Docker, Kubernetes, kubectl, Helm, ingress and rollouts. It prepares you for roles such as Cloud engineer, DevOps engineer and Platform engineer.

Does Kubernetes from Zero guarantee a job?

No. No placement rate is published because there are no graduates to count yet. What you leave with is graded, deployed work on one record an employer can open and run, and a hiring plan you keep with the career agent.

How do I join Kubernetes from Zero?

Reserve one of the twenty-five founding spots on this page with your email. Spot holders hear the opening date first, and nothing is charged before you confirm. The price on this page is in Australian dollars and is the same in every country.

25 spots. Hold one of them.

25 founding spots. Recorded by an instructor who does this work, graded by Nova. Spot holders hear the opening date first, and nothing is charged before you confirm.

  • You can deploy, scale and debug applications on Kubernetes
  • Three graded projects on your record
Reserve my spot

About a minute. No account, no card, and nothing is charged until you confirm.