Skip to content

Prove your Docker skills

Plenty of developers can run a container. Fewer can explain why an image is huge, why a build cache keeps missing, or why a container dies on start. Lemma records that deeper Docker skill.

How Docker is assessed

Preparing for an interview? Docker interview questions, junior to senior

What Docker competence looks like

Someone fluent in Docker writes Dockerfiles that build fast and ship small. They order layers so the cache works, use multi-stage builds to leave compilers behind, and run as a non-root user by default. Secrets stay out of images, and base images are pinned and kept current.

When a container misbehaves, they debug methodically. They read the logs, exec into the container, check the entrypoint and environment, and compare it with what works locally. They use Compose to make local environments match production closely enough that 'works on my machine' stops being a meeting topic.

Docker session
Live · 41:07

Live container troubleshooting

60 min · Learning · with Ava T.

Dockerfile Iris V. is sharing
12
13
14
15
16
17
18
19

Ava T. rated the session

Practitioner · after the call

Clear reasoning on dockerfile design. Talked through trade-offs first.

Added to DockerAdded to record

Dockerfile design

Layer ordering, caching and multi-stage builds that keep images fast to build and small to ship.

Image security

Non-root users, minimal base images, pinned versions and keeping secrets out of layers and history.

Docker Compose

Multi-service local environments with networks, volumes and health checks that mirror production behaviour.

Networking and volumes

How containers reach each other, publish ports and persist data without surprises on restart.

Debugging containers

Reading logs, inspecting state and exec-ing in to find why a container crashes or hangs.

Registries and CI builds

Tagging, pushing and building images in CI so every deploy uses a known, reproducible artifact.

What counts as evidence of Docker skills?

Certificates in Docker show an exam was passed. Lemma records how you work: sessions where you talked through a design or an incident, an adaptive test, and configuration in repositories you link. Every entry says where it came from. See the evidence methodology for how each source is weighed.

Skills Passport
Signed
64

Docker

Clara W. · SCI recomputed 9 Oct

Evidence · 4 entries

  1. Dockerfiles and Compose in a repo

    GitHub connector · 9 Oct

    Verified
  2. Diagnosing a problem Dockerfile

    Adaptive assessment · 2 Oct

    Level 7.2
  3. Live container troubleshooting

    Live session · 24 Sep

    Rated 5.0
  4. Drills on layers and networking

    AI tutor practice · 11 Sep

    Practice
Signature valid · checked today Share link
GitHub connector

Dockerfiles and Compose in a repo

Connect GitHub and attach a repository or commit with your Dockerfiles and Compose setup. Lemma confirms your account can access it and re-checks the link over time.

Adaptive assessment

Diagnosing a problem Dockerfile

The adaptive assessment shows realistic situations, such as a Dockerfile that bloats, leaks a secret or fails to start, and you choose the correct diagnosis or fix from the options.

Live session

Live container troubleshooting

In a session, a practitioner hands you a misbehaving container setup and watches you diagnose it. Methodical debugging, not memorised commands, is what earns a strong rating.

AI tutor practice

Drills on layers and networking

The AI tutor gives short exercises on caching, multi-stage builds and container networking. It prepares you for assessments and adds only a small, capped amount to practice.

How is a Docker skills test run on Lemma?

The Docker test is adaptive, 15 to 25 questions on failure modes, permissions and cost rather than service names, and it stops once your level holds steady. With sessions and linked work it sets your Docker SCI, where recent evidence carries more weight.

Docker assessment
0:42
Question 11Stops when your level holds
Difficulty7/10

An image is 1.4 GB and ships the compiler. What reduces it most?

  1. AA .dockerignore on its own
  2. BSquash all the layers
  3. CA multi-stage build with a slim runtime
  4. DPin the base image tag
Locks on submit
  1. Attach your container setups

    Connect GitHub and link the repositories where your Dockerfiles and Compose files live. A reviewer can see you have containerised real services, not just followed a tutorial.

  2. Debug a setup in a live session

    Book a session with a Docker practitioner and work through a broken or slow container setup together. They rate how you narrow the problem down and explain the fix.

  3. Pass the adaptive Docker assessment

    Scenario-based multiple-choice questions cover images, networking and security. Difficulty adjusts after every answer, harder questions count for more, and each one is timed with no going back.

Docker skills: common questions

How do I prove Docker skills to an employer?

Show real containerised projects and be ready to debug one live. On Lemma, attach repositories with your Dockerfiles and Compose files through GitHub, work through a broken setup in a live session, and take an adaptive assessment built on realistic Dockerfile scenarios. All of it lands on your Docker record.

What Docker questions come up in DevOps interviews?

Common topics include layer caching, multi-stage builds, the difference between images and containers, networking between services, persisting data with volumes and running as non-root. Interviewers often hand you a slow or failing Dockerfile. Practising exactly that in sessions and assessments is useful preparation.

What does a good Dockerfile look like in a portfolio?

A good Dockerfile is short, readable and deliberate. It uses a minimal pinned base image, orders layers for caching, uses a multi-stage build where compilation is needed, runs as a non-root user and keeps secrets out. A brief comment on why each choice was made helps reviewers.

Should I learn Docker before Kubernetes?

Usually, yes. Kubernetes schedules and manages containers, so understanding images, networking and container lifecycles first makes it far easier to follow. Building solid Docker evidence also gives you a foundation that carries into DevOps and cloud architecture records on Lemma.

Start your Docker evidence record.

Lemma is in early access. Request an invite and we will email you when your place is ready.