The wrong-answer log, and how the app repeats your misses
In plain words
Imagine learning to juggle. Every time you drop a ball, you write down which throw it was and why: "left hand threw too high", "looked at my feet". Then you practise that one throw until it's boring, and come back to it a few days later to check it's still there. The notebook isn't a diary of your feelings; it's a list of throws to practise.
The wrong-answer log is that notebook for the CKA: every miss with its date, task, time taken, the why and the rule that fixes it. Each miss gets a kind: knowledge, speed, reading or environment, and each kind has a different cure. The app does the repetition: attempts for timings, redo for a fresh attempt, drill for a new randomised round, review for spaced questions.
Every miss, written down, redone until it is boring
The problem. Doing drills you already know feels productive and teaches nothing. Writing down every miss and why, then redoing exactly those, is what moves your score.
What you need to know already: the drills of this chapter (19.8-19.41), and the app's attempts, redo and solution commands.
The plan's rule: log every wrong answer with the reason, and re-do it until it is automatic. The log is not a diary - it is a queue of things to drill.
What a line in the log looks like
date source task result minutes why fix / rule
2026-10-03 killer.sh 1 Q7 etcd restore wrong 14 changed --data-dir, not the hostPath restore = new dir + etcd-data hostPath
2026-10-03 killer.sh 1 Q12 NetworkPolicy partial 9 one dash too many: AND became OR peers: own dash = OR, same dash = AND
2026-10-04 sysop 19.d podfix (oom) slow 11/6 read the whole describe Last State + Events only
2026-10-04 sysop mock 2 T1 control plane wrong ctx 7 did it on wk8s use-context before reading
Keep it in a plain file in your lab repo (~/oncall-lab/cka-log.tsv) - greppable, diffable, yours.
Classify every miss
The "why" is what makes the log useful. Four kinds, four different cures:
kind
example
cure
knowledge
did not know the restore changes the hostPath
re-read the chapter section, then the drill
speed
right answer, 11 minutes on a 6-minute task
the drill again, same day and in 3 days, until under budget
reading
"only role=A" - allowed B too; wrong file name
nothing to learn - the pre-flight line, every task
environment
wrong context, Ctrl+W closed the tab, paste staircased
the habit list; fix the editor settings
If most of your misses are reading and environment, you are ready and just need calmer passes. If they are speed, you need more rounds. If they are knowledge, go back to chapters 15-18 for that topic.
Spaced repetition: what the app does for you
You do not need a flashcard system on top - the app already has the pieces:
attempts lists every attempt at a mission or drill round: when, how long, how many hints, whether you looked at the solution. That is your timing data for the log.
solution shows the reference answer as a commented session, and marks the attempt assisted. An assisted attempt does not count as "done from memory".
redo [N.M] rebuilds that lab and starts a fresh attempt; the step stays done. For a drill, drill starts a new randomized round: same shape, new names, new fault.
journey marks a step * once you have done it from memory at least once - the goal for every drill in this chapter is a * AND a time under its budget.
review runs the spaced-repetition deck (debrief questions come back on a schedule, sooner when you get them wrong).
The loop for a miss: log it -> redo it the same day without hints -> drill a fresh round of the same type in two or three days -> once it is under budget twice in a row, strike it from the log.
A week of drilling, concretely
Each day: two or three drills from the heavy domains (troubleshooting, architecture, networking), one from the others, plus the redo queue from the log.
Every third day: the random five-task block (35 minutes).
Weekend: one mock exam, timed, then the debrief and the log.
Never more than 20 minutes on one task in practice either - the eight-minute rule is a habit, not an exam trick.
When the log says you are ready
No knowledge misses in the last week.
Every drill type done from memory under its budget at least twice.
Mock 3 under 100 minutes with all objectives, twice.
killer.sh session one redone clean (untimed) at least once.
Then book the exam, do killer.sh session two 48 hours before it, and log that too.
Why it helps
Practising what you're already good at feels productive and changes nothing; practising your misses is where the score moves. A log turns vague "I'm bad at storage" into "I changed --data-dir instead of the hostPath, twice", which has a precise fix. Classifying misses also tells you when you're ready: if they're mostly reading and environment, you need calmer passes, not more study.
This is also how good engineering teams learn: incidents recorded with the symptom, the cause and the fix, classified, with follow-up actions tracked until done. Keeping your own log is a small, personal version of a postmortem culture, and it gives you concrete stories for interviews ("the three mistakes I kept making and how I fixed each").
FAQ
What should a line in the log contain?
Date, source (killer.sh, a drill, a mock), the task, the result (wrong, partial, slow), minutes taken versus the budget, why it went wrong, and the rule that fixes it, like "restore = new dir + etcd-data hostPath". Keep it in a plain file in your lab repo, such as a TSV, so it's greppable and yours.
Why classify misses into four kinds?
Because each needs a different cure. Knowledge: re-read the chapter section, then drill. Speed: the same drill again the same day and in three days until it's under budget. Reading: nothing to learn, apply the pre-flight line every task. Environment: fix the setup and habits (context first, editor settings, no Ctrl+W). Mixing them up wastes practice time.
How does redo differ from drill?
redo rebuilds the same lab and starts a fresh attempt at that exact step, so you can repeat a miss the same day without hints. drill starts a new randomised round of the same task type: same shape, different names, namespaces and faults, which tests that you learned the pattern, not the answer. Use redo first, drill a few days later.
Does looking at the solution count as done?
The step can be done, but the attempt is marked assisted, and assisted attempts don't count as "done from memory". journey shows a * only for steps you've completed from memory at least once. The goal for every drill in this chapter is a * and a time under its budget.
When can I strike a miss from the log?
When you've done that task type from memory under its budget twice in a row, on different days. The loop: log it, redo it the same day without hints, drill a fresh round two or three days later, and once it's under budget twice, strike it. If it comes back later, it goes back in the log.
In an interview Junior
How do you practise a technical skill so it sticks?
By working on the misses, not the things you already know:
Log every miss with its reason and the rule that fixes it - a plain greppable file: date, source, task, result, minutes, why, fix.
Classify the why, because each kind has a different cure: knowledge (re-read, then drill), speed (the drill again until under budget), reading (a pre-flight routine), environment (fix the habit or the editor settings).
Spaced repetition: redo the miss the same day without hints, a fresh randomized round two or three days later, and strike it once it is under budget twice in a row. Assisted attempts (looked at the solution) do not count as done from memory.
Measure: time per attempt, against a budget.
The same idea scales to a team: a blameless log of incidents with symptom, cause and fix, turned into runbooks and drills, so a mistake is made once.
Also asked: How do you learn from mistakes, yours or the team's? · How would you build a runbook culture on a platform team? · How do you know when you are ready for an exam or an on-call rotation?