Translate | Translation Mock Exams: Measure Readiness and Plan the Next Attempt

Translation mock exams are most useful when they measure an integrated translation system rather than produce a dramatic score. A strong mock brings together source reading, passage or task selection where applicable, terminology research, target-language drafting, time management, revision, resource rules and submission behaviour under conditions that resemble the assessment you are preparing for.

This translation exam practice guide shows how to build, run and interpret mock translation tests without confusing simulation with prediction. A mock can reveal whether skills that work separately still cooperate across a complete examination session. It can show where time moves, which errors recur, whether later tasks deteriorate, whether revision survives pressure, and what should be repaired before the next attempt.

Use official materials and current candidate instructions whenever you are preparing for a named credential. ATA and NAATI currently provide qualification-specific preparation resources, while CIOL publishes information for its Diploma in Translation. Their structures are not interchangeable, so this article teaches a general translator mock exam performance system rather than inventing one universal mock format. ATA certification preparation NAATI Certified Translator CIOL Diploma in Translation

Your 50-second route

If you have never completed a representative timed translation, return first to Timed Translation Tests. If individual passages are stable but the full session breaks down, begin here with mock fidelity and task sequencing. If your mock score or feedback is confusing, go to evidence interpretation. If the same error appears across mocks, stop simulating and repair it. If performance is stable, use the final sections to decide what the next practice format should measure.

Route 1 — Build a representative mock

Use Sections 1–6: define the assessment, match the environment, select appropriate material, preserve resource rules and establish the observation plan.

Route 2 — Run the full simulation

Use Sections 7–12: start routine, task sequence, switching, pacing, recovery, revision and submission.

Route 3 — Interpret the result

Use Sections 13–19: product review, process trace, error families, timing, variability, support conditions and evidence freshness.

Route 4 — Repair before another mock

Use Sections 20–26: isolate the bottleneck, teach it, drill it, transfer it and decide when another full simulation has enough informational value.

Route 5 — Plan the next attempt

Use Sections 27–32 and the laboratories: compare repeated mocks without pretending they predict the examination, preserve what works and choose the next evidence-producing task.

This page owns integrated mock-exam simulation and post-mock planning for translation. It does not replace the wider Translation Exam Preparation owner, the worked-passage practice owner, or the timed-component owner. The general eduKateSG article How Mock Exams Fail remains the broad cross-subject owner; this article applies the mock architecture specifically to translation.

1. A mock exam is an instrument, not a performance

Adrian finishes a three-hour simulation and asks only one question: “Did I pass?” Jo asks a different set: Which decisions held up across the whole session? Where did quality change? Which task consumed unexpected time? What did revision catch? Which part of the result came from knowledge, and which part came from the environment? Jo’s questions make the mock useful even before any external scoring exists.

A mock is a measurement instrument built from a simulation. Its value depends on fidelity, observation and what you do after the result. A low-fidelity mock can create false confidence or unnecessary alarm. A high-fidelity mock without diagnosis can become expensive repetition. A well-designed mock produces evidence for the next training decision.

The first discipline is therefore to state what the mock is intended to test. Whole-session pacing? Task switching? Passage selection? Resource discipline? Sustained target-language quality? Revision under cumulative load? Platform familiarity? If the purpose is unclear, every observed difference can look equally important.

Do not ask one mock to answer every readiness question. A simulation can expose integration, but it may be a poor way to teach a known source-language construction. Once the mock identifies a local weakness, leave the mock format and repair the component more efficiently.

2. Define the assessment before you imitate it

Representative practice starts with the current official task structure. What language direction is tested? How many tasks are required? Is there passage choice? Is there a revision task? What is the overall or per-task time? Which resources are permitted? How is the response submitted? These details belong to the administering body and can change.

NAATI currently describes its Certified Translator test as a 3.5-hour test containing two translation tasks selected from three and one revision task. ATA’s current certification materials describe a three-hour online examination in which candidates translate two of three passages, with current resource and platform rules published separately. CIOL’s Diploma in Translation has its own unit and assessment architecture. A mock for one should not silently borrow the structure of another.

Make a one-page assessment specification from official sources. Include only operational facts needed for practice. Date it. Before a high-stakes rehearsal, verify that the specification is still current. This avoids building months of practice around an obsolete format.

If you are not preparing for a named credential, define your own educational task explicitly. State the number and type of texts, time window, permitted resources, target audience and review expectations. Call it a training simulation, not an official mock.

3. Fidelity has layers

Fidelity does not mean copying an official exam paper. It means matching the conditions that materially affect the skill you want to observe. Separate at least five layers: task fidelity, time fidelity, resource fidelity, environment fidelity and behavioural fidelity.

Layer	Question
Task	Does the practice require the same kinds of translation decisions?
Time	Does the timing reproduce the relevant constraint?
Resources	Are permitted and prohibited supports represented honestly?
Environment	Are device, input, platform and submission mechanics sufficiently familiar?
Behaviour	Is the learner actually working independently as intended?

A simulation can be strong on four layers and weak on one. Mira uses excellent unseen passages and exact timing but allows herself unrestricted machine translation during a mock for an assessment that does not. Her result measures a different task. Ryan uses representative resources but pauses the timer whenever he searches. His time evidence is no longer representative.

Fidelity should be high enough for the inference you want to make. A component drill can deliberately have low whole-exam fidelity because its purpose is learning. Label it correctly. Problems arise when a low-fidelity exercise is interpreted as full readiness evidence.

4. Use unseen material without confusing novelty with difficulty

A mock should normally use material the learner has not translated before. Otherwise memory of earlier decisions reduces the cost artificially. Yet unseen does not mean arbitrarily obscure. A passage can be novel while still resembling the assessment’s broad text types, complexity and expected domain range.

When using original educational material, record its provenance and design purpose. Do not call it an official past paper. If official sample or practice material is available, use it according to the provider’s terms. Preserve the distinction between provider-authored preparation and your own simulation.

Ben performs poorly on a mock containing specialist biochemical terminology far outside the intended general-domain task. The result tells him something about that passage but little about representative readiness. Difficulty without construct relevance is noise.

Conversely, using only familiar easy topics can inflate confidence. Build variation around the target task: different genres, sentence structures, reference chains, numbers, modality and terminology loads. Representative difficulty is a distribution, not one favourite passage.

5. Establish the observation plan before the clock starts

A mock should feel like a test to the learner, but the training system needs enough observation to explain the result later. Keep observation lightweight: start and end times, task transitions, major stalls, resource episodes, revision start, submission state and any unusual event.

Do not interrupt the learner to ask why they paused. That changes the simulation. Use screen or process logs only when lawful, ethical and appropriate, and avoid collecting unnecessary personal data. A simple self-marked trace at task boundaries is often enough.

Clara marks only six timestamps during a full simulation. Afterward those six points reveal that Task 1 consumed nearly half the session, leaving Task 3 with little revision. The trace is sparse but actionable.

Write the review questions before the attempt too. If the mock is testing task switching, plan to compare the first five minutes after each transition. If it is testing revision durability, record what the final sweeps catch. Precommitment reduces hindsight storytelling.

6. Keep the mock independent enough to mean something

A teacher can help before and after a mock, but live prompting changes what the attempt measures. If Aisha receives a reminder to check attribution midway through the test, the resulting target may be better, but it is evidence of guided performance. Save it as such.

Use three labels across the training programme: guided, supported and independent. Define them locally. Guided may include active prompts; supported may allow the intended resources but no teacher prompts; independent may reproduce the intended assessment conditions as closely as possible.

There is no shame in guided work. It is often the fastest way to learn. The mistake is comparing a guided result with an independent result as though the conditions were identical.

As competence grows, fade support. The moment when a learner can execute the repaired behaviour without the prompt is important evidence of transfer.

7. The start routine: enter the mock without wasting the opening

The opening of a full simulation should be boringly familiar. Confirm the task, language direction, permitted resources and submission mechanism before the timer begins. Once it begins, read the instructions, inspect the available work and execute the selection or risk-scan process you have already trained.

Adrian used to spend the first ten minutes rearranging windows and checking reference sites. His mock trace made the operational tax visible. He now prepares the representative environment before the start and uses the opening only for assessment work.

Do not introduce a new annotation system on mock day. A mock is primarily for testing the current integrated system. Experiments belong in component practice unless the experiment itself is the explicit object of the simulation.

If the official environment includes a system check or provider preparation module, use it beforehand. Platform familiarity should not consume the same attention as source interpretation when it can be trained separately.

8. Task sequencing is a translation decision

Where the assessment permits choice or flexible ordering, sequence can affect performance. A difficult task first may consume disproportionate time; leaving every difficult task until the end can create a final bottleneck. The correct sequence depends on the actual rules and the learner’s evidence.

Jo tests two sequences across separate representative simulations. In one, she completes her most structurally difficult translation first. In another, she begins with the task she can enter quickly. The comparison includes total quality and later-task degradation, not just which sequence feels better.

Do not change sequence casually between every mock. You need enough stability to learn from comparison. If the provider imposes a sequence, practise that sequence and use your energy on decisions you can actually control.

Sequence also includes revision. If the assessment contains a distinct revision task, treat it as its own cognitive job rather than leftover checking. Read the official task specification and train the mode switch.

9. Switching costs between tasks

Moving from one source to another is not instantaneous. Terminology, topic assumptions and target-language rhythm from the previous task can persist. A short reset helps prevent contamination: close or mentally release the previous source, read the new brief, establish the new audience and rebuild the local terminology state.

Ryan finishes a museum notice and immediately begins a public-health passage. He carries the word “participants” into a text whose source distinguishes applicants, selected candidates and attendees. The error is not caused by ignorance; it is a switching failure.

Practise the reset under the clock. It should take seconds, not become a ritual. The aim is to prevent previous-task context from silently becoming the new task’s context.

After the mock, inspect the first paragraph of every new task. If errors cluster there, switching deserves attention. If they do not, do not add unnecessary reset procedures.

10. Whole-session pacing

The timed-test article teaches pacing inside a task. A mock adds allocation across tasks. Build a provisional whole-session map from the official structure and your own task traces. Include transition time and final closure where the format permits.

The map needs decision checkpoints rather than rigid equality. If Task 1 is unexpectedly difficult, define how much extra time it may borrow before later tasks are endangered. If Task 2 finishes early, decide whether the saved time returns to an unresolved queue or remains as global reserve.

Ethan’s first mock uses equal time for every task. Review shows that the revision task reliably takes less time than one translation task, while passage selection takes longer than expected. His second allocation reflects observed work rather than aesthetic symmetry.

Do not publish Ethan’s allocation as a universal formula. The transferable method is measure, allocate, rehearse and update.

11. Recovery when one task overruns

A full mock needs a recovery protocol because one task can exceed its allocation. The first rule is to stop pretending the original plan still exists. Recalculate from the current state: time remaining, mandatory tasks, unresolved high-risk work and minimum viable revision.

Clara loses twelve minutes to a difficult sentence in Task 1. At the next checkpoint she reduces optional polishing, completes the remaining source and protects a smaller but real revision pass. She does not attempt to recover twelve minutes by rushing every later sentence equally.

After the mock, the recovery itself is reviewed separately from the original overrun. Perhaps the overrun came from poor research stopping; perhaps recovery was excellent. Do not label the whole session simply “bad.” Multiple processes can have different quality.

Train overrun recovery occasionally with a planted delay. It should be a known training condition, not a surprise designed to distress the learner. The objective is allocation under changed constraints.

12. Full-session revision and submission

By the final phase, cumulative load matters. A checking routine that works on one passage may degrade after several hours. This is one of the reasons full mocks add information beyond timed components.

Keep revision structured. For each translation task, verify source-to-target transfer, target-language quality and high-risk mechanics according to the system already trained. For any separate revision task, follow its own instructions rather than treating it as another copyedit.

Ben’s first mock shows that his final-task numerical checking disappears. The same check works in isolated practice. The mock therefore reveals an integration problem: the routine is not yet durable across the full session.

Submission is part of the simulation. Save the timed state before any untimed correction. Record whether every required task was submitted and whether any temporary markers remained. Operational closure can be trained.

13. Save the timed state before you improve it

The moment the mock ends, preserve what actually happened. Save or duplicate the target before correcting it. Record the finish time, incomplete work, unresolved marks and resource condition. This is the evidence layer. The improved version belongs to the learning layer.

Mira notices a missing negative seconds after the timer ends. She is tempted to fix it before saving because the correction is obvious. She does not. The timed version records the miss; the learning copy records the repair. Both are useful precisely because they are not conflated.

Honest state preservation prevents retrospective inflation. A mock that becomes better every time you review it can teach you a lot, but it no longer tells you what you produced within the simulated conditions.

Where the official platform provides a score or feedback, preserve that separately too. Do not overwrite provider feedback with your own categories. Different evidence sources can coexist.

14. Review the product and the process separately

Product review asks what is wrong, strong or defensible in the target. Process review asks how that target was produced. A correct term found after twelve minutes of searching is a good product decision with a potentially inefficient process. An incorrect term selected quickly can be a knowledge problem despite efficient pacing.

Use the worked-practice error families for the product: changed meaning, target-language problem, brief mismatch, defensible alternative and preference. Use the mock trace for the process: reading, selection, drafting, research, transitions, revision, recovery and submission.

Then connect them. Did late-task errors rise because revision time disappeared? Did terminology inconsistency begin after a task switch? Did a passage-choice decision create the overrun? Connections are more useful than isolated corrections.

Avoid explaining every error with fatigue or pressure merely because the session was long. The source construction may simply be unknown. Use evidence from component practice and error location before assigning a mechanism.

15. Read scores as evidence with limits

If the mock produces an official or teacher-generated score, ask what the score actually measures. Which rubric? Which tasks? Who marked it? Under what conditions? Is the material official, assessed practice, unassessed practice or locally created?

NAATI currently distinguishes its paid assessed practice test from the full Certified Translator test and explicitly notes that passing practice does not guarantee passing the actual test. That is a useful epistemic boundary: even high-quality practice evidence should not be converted into certainty about a future examination.

A local mock can still be valuable without pretending to predict. It can show that, on recent representative tasks, the learner completes all required work, preserves revision time and makes fewer identified transfer errors. Those are concrete observations.

Do not invent a pass probability from a handful of homemade mocks. Use official scoring information for the credential and keep local evidence at the scale it supports.

16. Error recurrence matters more than error drama

A spectacular one-off mistake attracts attention. A small repeated error can be more important for training. If every mock loses one upper-limit expression, the recurrence is a stable repair target. If one unusual cultural reference is mishandled once, investigate it without assuming a permanent weakness.

Create an error ledger across mocks. Record only consequential or recurring issues, not every stylistic preference. Group by mechanism where evidence supports it: modality, quantity, reference, terminology, target formulation, brief, research or revision.

Aisha sees one overstatement in Mock 1, another in Mock 2 and a third in Mock 3 across different topics. The common mechanism is source certainty. She stops running full mocks and returns to modality and attribution drills.

The mock has done its job when it identifies a stable repair target. Repeating another three-hour simulation immediately would be a poor use of information.

17. Look for position effects across the session

Map errors and time by task position. Are later tasks consistently slower? Does target-language quality decline? Does research become less selective? Does the final review disappear? A full mock can reveal position effects that isolated tasks cannot.

Ryan’s first task is consistently accurate. His second contains more reference errors. His third contains no more source errors but more awkward target prose. The pattern suggests different components may degrade at different points.

Do not call the pattern fatigue automatically. Task difficulty and genre may be confounded with position. Rotate comparable locally created tasks in another simulation where the official format allows your training design to do so. If the same position effect remains, the fatigue or sustained-attention hypothesis becomes stronger.

Where the real assessment fixes task order, the practical goal is durability in that order regardless of the precise mechanism. But diagnosis still improves the repair.

18. Measure variability, not only the average

Three mocks averaging a similar result can hide very different stability. One learner performs consistently. Another alternates between excellent and incomplete attempts. The average alone misses reliability.

Track ranges: total completion time, revision reserve, number of unresolved high-risk items and recurring error families. You do not need sophisticated statistics for a small training set. The question is whether performance remains usable across reasonable variation.

Clara’s first two mocks differ because one contains a sentence structure she has never seen. After teaching that construction, later attempts become more stable. Variability was informative because it pointed to a knowledge dependency.

Do not demand identical performance. Different texts legitimately cost different amounts. Robustness means the system adapts without collapsing, not that every number is constant.

19. Evidence freshness: an old good mock is not current readiness

Performance evidence ages. A strong mock from months ago shows what the learner could do then under those conditions. Knowledge can improve, decay or change; the assessment format can change; resource rules can change. Readiness claims should use reasonably fresh evidence.

Freshness does not mean running full mocks constantly. Use cheaper component checks between simulations. A recent timed passage can show whether a repaired skill remains stable. A later full mock can test integration again.

Record dates and versions of official instructions used for the simulation. If the provider changes the platform or task architecture, older mock evidence may still teach language but becomes less representative operationally.

The existing eduKateSG Evidence Freshness article owns the general learning principle. Here it is applied specifically to translation mock evidence.

20. Stop mocking when the mock has already answered the question

If three simulations show the same failure, the next useful action is usually not a fourth simulation. The measurement phase has enough evidence to commission a repair. Full mocks are expensive because they consume whole-session time while providing relatively little repetition of the specific weak decision.

Ben loses quantity boundaries across two mocks. A third confirms the pattern in a different genre. He now spends several shorter sessions on quantifier recognition, source-to-target boundary transfer and fresh paragraph retests. Only after the component improves does he return to the full session.

This principle protects learners from simulation theatre: the feeling of serious preparation produced by repeatedly sitting long tests without changing the underlying process.

Return to a mock when integration is again the open question. The mock should test a hypothesis that component work cannot answer cheaply.

21. Convert the mock into a repair specification

A repair specification contains five parts: observed failure, likely mechanism, evidence supporting the mechanism, training task and fresh transfer test. Keep it narrow.

Field	Example
Observed failure	Three conditional exceptions omitted across two tasks.
Likely mechanism	Source-language exception structures not recognised reliably under time.
Evidence	Same structures also missed in untimed explanation.
Training	Explain + contrast + translate fresh exception sentences.
Transfer test	Unseen paragraph with hidden exception structures.

If the evidence shows the learner understands the structure untimed but loses it only late in the session, the repair specification changes. You might train a final boundary sweep or sustained-attention routine rather than reteach grammar.

The specification prevents vague prescriptions such as “practise more translation.” It says what should change and what future evidence would count as improvement.

22. Repair knowledge before performance when knowledge is missing

A mock can reveal that the learner simply does not know something: a grammatical construction, a genre convention, a recurring institutional term or a target-language pattern. Do not frame every missing knowledge unit as time management.

Teach the concept untimed. Ask the learner to explain it. Use contrasting examples. Translate fresh units. Retrieve it later without notes. Only then add time pressure.

Adrian’s mock shows repeated confusion between two institutional roles. The terms look similar in the source language. More timed passages would repeatedly measure the confusion. A short concept lesson with authentic examples makes the later decision cheaper and more accurate.

Performance training works best when the underlying representation is sound. The clock should compress a correct process, not force a learner to improvise around missing knowledge.

23. Repair process when knowledge is present but execution fails

Sometimes the learner explains the source correctly after the mock and can produce a strong target untimed. The failure occurred in execution: overresearch, late revision, task switching, premature polishing or failure to return to an unresolved mark.

Process repairs need representative constraints sooner than knowledge repairs. If Mira’s issue is endless rewriting, practise the completion line under a modest timer. If Clara’s issue is one hard sentence consuming the task, rehearse stop-loss and return inside paragraphs.

Keep the language material easy enough at first that the process is visible. Then increase linguistic difficulty. Otherwise you cannot tell whether the process repair failed or the source simply exceeded current knowledge.

Once the process works in short tasks, integrate it into a half-session or full mock. Scale should increase after reliability, not before it.

24. Repair target-language durability

Some learners preserve meaning throughout the mock but target-language quality deteriorates in later tasks. Sentences become source-shaped, punctuation becomes inconsistent or register drifts. This deserves its own repair rather than being lumped into “fatigue.”

Use target-only reformulation drills after sustained source work. Translate a short passage, switch tasks, then read the target without the source and repair naturalness. Build genre patterns outside the clock so they are cheaper to retrieve later.

Aisha practises public notices, formal correspondence and explanatory prose separately. She learns stable target-language structures for conditions, dates and attribution. During later mocks, she spends less effort inventing every sentence from scratch.

Do not reward elegance that changes the source. Target-language durability must remain inside the fidelity boundary.

25. Repair resource discipline

A mock can expose poor resource routing. The learner may use a bilingual dictionary for a discourse problem, general web search for an official institutional title, or repeated search for a collocation already confirmed. Each mismatch consumes time.

Create a resource-routing drill: present ten uncertainties and ask which evidence source should be tried first. Grammar, context, official glossary, monolingual dictionary, corpus or parallel text may each be appropriate depending on the question and the permitted environment.

Then train stopping. A resource strategy without stopping criteria can still sprawl. Record which lookup changed the target and which merely reassured.

Always respect the actual assessment’s current resource rules. A brilliant workflow built around an unauthorised tool is not readiness for that assessment.

26. Retest the repair before paying for another full mock

A repair should survive fresh material before it returns to a whole-session simulation. Use an unseen micro-task containing the same decision type but different surface vocabulary. If the learner succeeds, embed it in a paragraph. Then use a timed passage. Only then ask whether a full mock adds useful information.

Ryan repairs reference chains with short examples. His first paragraph retest succeeds. His timed passage succeeds. The next full mock can now test whether reference remains stable after task switching and cumulative load.

If the fresh passage fails, another full mock is premature. Return to diagnosis. Perhaps the repair was memorised rather than understood, or perhaps the original mechanism was wrong.

This staged return keeps practice efficient: explain, drill, transfer, time, integrate.

27. Compare mocks by conditions, not just outcomes

Before comparing Mock 1 with Mock 2, compare the conditions. Were both independent? Were the passages similarly representative? Was the language direction the same? Were resource rules identical? Was one attempt interrupted? Did the official task format change? Outcome comparison without condition comparison can create false narratives.

Use a compact header on every mock record: date, task specification version, language direction, independence level, material source, time condition and permitted resources. These few fields make later interpretation much stronger.

Jo’s Mock 2 finishes faster than Mock 1, but Mock 2 uses material she partially encountered in a class discussion. She does not call the difference a speed gain. She marks the attempt as less independent and looks to Mock 3 for cleaner evidence.

This discipline prevents practice data from becoming a collection of incomparable numbers.

28. Preserve successful behaviours between mocks

Post-mock review often focuses entirely on failure. That can accidentally dismantle effective routines. Record what worked and should remain stable: passage scan, research stopping, transition reset, revision reserve, numerical check or submission routine.

Ethan’s mock shows one terminology problem but excellent pacing and revision. His next training cycle targets terminology while preserving the time architecture. He does not rebuild the entire system because one component failed.

Stable strengths also reduce cognitive load. A learner who knows their opening and revision routines can allocate more attention to the source itself.

When a previously stable behaviour degrades in a later mock, investigate what changed. A new repair may have displaced it. Training has interactions.

29. Decide the next attempt from the unresolved question

Ask: what do we still not know that matters for preparation? If you do not know whether the learner understands conditional exceptions, use a short knowledge task. If you do not know whether a repaired skill survives time pressure, use a timed passage. If you do not know whether several repaired components survive the whole session, use a mock.

This is an information-value approach to practice. The next task is selected because its result can change the plan. A full mock is justified when the unresolved question is genuinely system-level.

Adrian’s latest passage shows research discipline is repaired. His target-language quality is stable. What remains unknown is whether he maintains both across multiple tasks. A full simulation now has value.

Ben still misses upper limits in short passages. A mock does not have value yet because the answer is already known: repair quantity boundaries.

30. Do not chase a perfect mock

A mock with no identified errors can be encouraging, but perfection is not a sensible prerequisite for every next step. Translation permits defensible alternatives, texts vary and review can always discover another stylistic option. The aim is dependable performance under the required conditions, not an artificial zero-difference target.

Likewise, one imperfect mock does not erase earlier evidence. Look at the pattern, the cause and whether the failure is repairable. A single difficult passage can widen the evidence set rather than invalidate it.

Use official assessment standards for actual qualification decisions. Local mock analysis should support preparation, not invent a harsher private standard than the credential itself.

The useful question after a strong mock is often not “How do I make this perfect?” but “What remaining uncertainty would most improve the next decision?”

31. Final-week mocks: protect learning value

Close to an examination, a full mock can provide useful confirmation or expose a late issue, but it can also consume a large block of time that might be better spent repairing a known weakness. Do not run one simply because the calendar says “mock day.”

If recent representative evidence is stable, use the final phase to preserve familiar execution and review official logistics. If a known component remains weak, targeted work may have higher value. If the learner has never experienced the full platform or session length, a representative rehearsal can still be important.

There is no universal number of mocks in this article. The correct count depends on what each simulation teaches and the cost of running it. Stop when additional mocks are not changing the plan.

Keep provider-specific advice with the provider. Check current official instructions before the actual assessment.

32. The mock-exam loop

The complete loop is simple enough to remember: specify → simulate → preserve → review → diagnose → repair → transfer → resimulate. Each arrow has a purpose. Specify prevents false fidelity. Preserve prevents retrospective inflation. Diagnose prevents generic practice. Repair changes the mechanism. Transfer checks whether the change survives new material. Resimulation tests integration.

Adrian, Jo, Ben, Aisha, Ryan, Mira, Clara and Ethan can all use the same loop while receiving different repairs. The loop is common; the bottleneck is personal.

Do not skip from review directly to resimulation when the same weakness is known. That produces measurement without intervention. Do not skip transfer when a repair works only on the teaching example. That produces rehearsal without generalisation.

A mock exam is successful when it makes the next training decision better—even when the result itself is disappointing.

Mock laboratory A — Fidelity audit

Before the next full simulation, audit the mock against the current assessment specification. Make five columns: task, time, resources, environment and behaviour. For each, write “matched,” “deliberately different” or “unknown.” Unknowns must be resolved before the result is interpreted strongly.

A deliberate difference can be legitimate. You may shorten a session because the learner is training transitions rather than endurance. Label it. The danger is accidental difference disguised as fidelity.

After the mock, revisit the audit. Did an apparently minor mismatch affect performance? Perhaps the learner used a different keyboard layout or the local mock omitted passage choice. Add the observation to future design.

Over time, the audit becomes shorter because stable conditions are already known. Keep it as a preflight rather than a bureaucratic burden.

Mock laboratory B — Task-transition microscope

Take a completed full simulation and inspect only the first five minutes after each task transition. What did the learner do? Did they reread the new brief? Did previous terminology leak? Did they research before understanding the new paragraph? Did typing or target-language rhythm take time to reset?

Now build a two-task mini-simulation using different genres. Train a ten-second reset: release old context, read new brief, identify audience and purpose, scan the first paragraph. Repeat until the transition no longer produces predictable errors.

Then remove the explicit prompt and retest. If the learner resets independently, the scaffold can fade. If not, return to guided practice.

Do not add a reset routine when no transition problem exists. The microscope is diagnostic, not a requirement for everyone.

Mock laboratory C — The overrun simulation

Start a multi-task practice session with a known five-minute deficit or deliberately make the first practice task slightly longer. Tell the learner in advance that the session tests recovery. They must protect completion and meaningful revision without pretending the lost time will return.

Observe which work is sacrificed first. If high-risk checking disappears before optional polishing, the recovery priorities are wrong. If the learner abandons an entire later task to perfect the first, whole-session allocation needs repair.

Afterward, restore normal conditions. The purpose is to train a contingency, not normalise permanent shortage.

Compare the recovery with an earlier naturally overrun mock. Did the learner make better trade-offs? The lab tests whether the post-mock lesson changed behaviour.

Mock laboratory D — Score-blind review

Where a mock has a score, hide it initially. Review the product and process first. Ask the learner to identify strengths, uncertainties, likely error families and timing issues. Then reveal the score or external feedback.

This prevents the number from dominating interpretation. A high score can coexist with a fragile process that happened to meet familiar material. A lower score can contain one narrow repairable weakness inside an otherwise controlled system.

Compare self-review with external feedback. Which issues were visible to the learner? Which were missed? Calibration itself becomes a training target.

Do not use score-blind review to dismiss official scoring. The external result remains important evidence. The sequence simply protects richer diagnosis before the number frames the conversation.

Mock laboratory E — Same mechanism, different surface

Choose one recurring mock error and build three fresh tasks around the same mechanism with different topics. If the error is attribution, use a museum survey, a workplace report and a public consultation. If it is numerical scope, use borrowing limits, event capacity and dosage-free materials inventory examples.

Train the mechanism untimed, then lightly timed, then inside a passage. Do not reuse the exact original sentence. The learner must recognise the relationship independently.

When the learner succeeds across surfaces, put the mechanism back into a full mock without announcing where it appears. That is the integration test.

This laboratory is the bridge between error correction and transfer. Without it, a repaired mock can become a memorised answer.

Mock laboratory F — Revision durability

Run three short translation tasks back-to-back. Require the learner to use the same final checking routine on each. Compare what the routine catches in Task 1, Task 2 and Task 3 and how long it takes.

If the final task’s checking becomes superficial, identify which part disappears first. Perhaps target-only reading survives but source comparison collapses. Train that component after sustained work rather than only when fresh.

Then repeat on another day with task difficulty balanced differently. This helps separate position from text difficulty.

Revision durability is a system property. A routine that exists only in isolated practice is not yet integrated.

Mock laboratory G — Resource-budget audit

From a completed mock, list every meaningful resource episode: question, resource used, time spent, answer changed or unchanged. Sort episodes into productive, necessary-but-expensive and low-yield.

For each low-yield episode, design a cheaper route. Perhaps context answered it, a better glossary existed, or the current target was already defensible. For necessary-but-expensive episodes, build prior knowledge so the same question costs less next time.

Do not aim to eliminate research. Good translation often requires evidence. The target is efficient question-to-evidence routing under the permitted rules.

Retest with fresh terminology. A resource strategy that works only on known terms is not yet a strategy.

Mock laboratory H — The no-change control

Not every mock should trigger a redesign. After a strong representative attempt, deliberately preserve the entire process for the next comparable simulation. Change only the material. This creates a no-change control.

If performance remains stable, you have stronger evidence that the system is robust across material variation. If it changes sharply, inspect the source before modifying the process. The difference may be text difficulty rather than a failed routine.

Training programmes often change too many variables at once. The no-change control teaches restraint and makes causal stories less speculative.

Preserving a good system is an active decision, not absence of teaching.

Resident case 1 — Adrian’s false readiness signal

Adrian completes his first mock comfortably inside the time. His target is strong. He concludes that the system is ready. Review reveals that the passages contain terminology he studied the previous week and the simulation allowed a resource not available in the intended assessment. The result is still useful, but its readiness meaning is narrower than he first believed.

He records the attempt as supported familiar-domain practice. The next simulation uses unseen material and representative resources. It takes longer and exposes his tendency to overresearch unfamiliar institutional terms.

The second mock looks “worse” but produces better training information. Adrian now knows what to repair. Readiness evidence improves when conditions become more representative, even if the headline outcome becomes less flattering.

His next action is not another mock. He trains bounded terminology research and retests it in fresh passages.

Resident case 2 — Jo’s sequence experiment

Jo has two translation tasks plus another required task in her local simulation design. Her first mock begins with the hardest translation. She spends too long establishing terminology and rushes the second half. Her second mock begins with the more accessible translation and leaves the harder one later. Total completion improves, but target-language quality on the last task declines.

She does not declare a winning sequence after two attempts. The passages differ. Instead she looks for the stable issue: the harder task has no research stop-loss and consumes whatever time is available.

She repairs research discipline first. In a later representative simulation, both sequences become more manageable. The original “sequence problem” was partly a local process problem.

Jo’s case illustrates why mock comparisons should not jump from outcome to cause. Sequence, passage difficulty and process interact.

Resident case 3 — Ben’s stable recurring error

Ben’s three mocks differ in topic and overall result, but each contains one quantity-boundary error. In one, “up to four” becomes “four.” In another, “at least 60%” becomes “60%.” In the third, “fewer than 20” becomes “20 or fewer.”

The recurrence is more informative than the changing total score. He leaves full simulations and works on upper, lower and inclusive boundaries. He explains each relation, translates fresh examples and checks them in paragraphs.

His next timed passage is clean. A later mock hides several quantity boundaries among easy vocabulary. He preserves them. The repair has now survived integration once.

Ben keeps the quantity sweep for another cycle before deciding whether it can fade. One success is encouraging, not permanent proof.

Resident case 4 — Aisha’s fluent late-session overstatement

Aisha’s first tasks read beautifully. In the final task, a survey “suggests” an effect and she writes that it “shows” the effect. The same distinction is correct in isolated practice. The mock reveals that epistemic calibration is less durable late in the session.

Her repair combines sustained-work drills with an attribution-and-certainty check. She completes two short tasks, then translates a third paragraph containing mixed evidence levels. The aim is to practise the decision after prior cognitive work.

In the next full simulation, the certainty distinction holds. Her target remains natural. The new evidence supports the repair without proving it can never fail again.

Aisha preserves her strong target-language routines and changes only the late-session semantic check.

Resident case 5 — Ryan’s task-switch contamination

Ryan uses a repeated key term consistently in Task 1. Task 2 contains a similar-looking concept with a different role. He carries the first target term across automatically. Review shows the source itself was understood when discussed afterward.

His repair is a short transition reset: new brief, new entities, new repeated terms. He practises with pairs of unrelated short texts. The reset initially takes twenty seconds and later becomes almost immediate.

During the next mock, the first paragraph of Task 2 is clean. Ryan’s process trace shows he performed the reset without prompting.

The intervention can now shrink. If later mocks remain clean, the explicit reset label may disappear while the behaviour remains.

Resident case 6 — Mira’s score improves but the process worsens

Mira’s second mock receives better teacher feedback than her first. Yet the trace shows she used nearly all revision time polishing the opening and submitted the final task without a source comparison. The better outcome may reflect easier material rather than a better process.

Her teacher refuses to interpret the score alone. They preserve the successful language work but restore a protected full-session revision checkpoint. The next mock uses different material and asks whether the checking routine survives.

Mira’s case shows why process evidence can prevent a favourable outcome from hiding fragility. A mock is not useful only when it finds failure.

She keeps both results in the ledger with condition notes rather than ranking one as simply “better.”

Resident case 7 — Clara’s recovery succeeds

Clara’s first task overruns because of a hard sentence. This time she notices at the checkpoint, writes the best supported provisional version and moves on. She completes all tasks and retains a short revision reserve. The hard sentence remains imperfect, but the whole session no longer collapses.

Post-mock review separates two findings. Hard-sentence parsing still needs work. Recovery has improved. She receives credit in the training record for the process gain while still repairing the source-language weakness.

This distinction matters pedagogically. A learner can improve one subsystem even when the final product still contains an error. If review sees only the error, the successful recovery behaviour may be lost.

Clara’s next work therefore has two lanes: structural parsing drills and preservation of the new stop-loss routine.

Resident case 8 — Ethan’s clean mock and the decision not to change

Ethan completes a representative simulation with controlled timing, complete tasks, meaningful revision and no consequential issue found in careful review. The temptation is to add harder checklists so preparation still feels active.

Instead, he preserves the system and changes the material. His next attempt uses a different genre and unfamiliar topic under the same conditions. Performance remains stable.

That no-change decision is informative. It suggests the existing process is robust enough across the observed variation. Ethan can move attention to official logistics and ordinary maintenance rather than redesign.

A good training system knows how to stop adding machinery.

Deep mock system 1 — Build a task specification sheet

A task specification sheet is the contract between the mock and the inference you hope to make. Put the assessment name or training purpose at the top. Record language direction, required task types, number of tasks, selection rules, time architecture, permitted resources, target expectations, platform and submission procedure. Add the date and official source links.

Then separate stable facts from details that may change. The existence of a translation task may be stable; a whitelist of websites can change. Mark volatile details for rechecking close to the assessment.

For locally created simulations, add a construct note: “This mock is designed to test general non-specialist translation, task switching and revision durability; it is not designed to predict performance on specialist legal translation.” Boundaries make later conclusions safer.

Give the sheet a version number. If the official rules change, update the specification and mark which earlier mocks used the old version. Historical practice remains useful, but operational comparability changes.

This small governance step prevents a common failure: treating the word “mock” as if it automatically guaranteed representativeness.

Deep mock system 2 — Build a passage portfolio instead of a single favourite test

One practice paper cannot represent the full range of decisions a translator may encounter. Build a portfolio of unseen or protected materials across relevant genres and mechanisms. Tag each by broad features rather than by an invented difficulty score: information density, terminology load, numbers, modality, reference chains, quotations, institutional language and target genre.

When constructing a mock, select a combination that resembles the intended task family without deliberately targeting only the learner’s known weakness. A mock is a sample of performance; a drill is where you concentrate a weakness.

Keep used passages out of the unseen pool. They can move into the teaching library for later comparison, model analysis and error drills. This preserves the value of future independent simulations.

If you have few materials, use shorter unseen passages for transfer checks and reserve full mock materials carefully. Repeating a full mock can still teach, but it should no longer be interpreted as clean unseen evidence.

Where copyright or provider terms restrict reuse, respect them. Link to official resources rather than reproducing protected exam content.

Deep mock system 3 — Create a pre-mock hypothesis

Before the simulation, write one or two hypotheses based on recent training. “Research stopping should preserve at least a real revision phase.” “Reference-chain repair should survive the second task.” “Target-only quality may degrade late in the session.” The mock can then confirm, weaken or complicate these hypotheses.

A hypothesis prevents review from becoming an unlimited hunt for patterns after seeing the result. You can still notice unexpected findings, but you have at least one predeclared question.

Do not make the hypothesis a desired outcome. “I will pass this mock” is not a useful process hypothesis. “The revised passage-selection scan should prevent late switching” is testable and actionable.

After the mock, state the evidence for and against the hypothesis. If the result is ambiguous because the task never contained the relevant feature, mark it unresolved rather than forcing a conclusion.

Deep mock system 4 — Use an event log without turning the mock into surveillance

A minimal event log can contain task start, task end, major research start/end, transition, revision start and submission. The learner can mark these with a simple notation or reconstruct them immediately after the session if the environment does not permit live logging.

The log should collect only what is necessary for training. Do not record unrelated personal behaviour or use intrusive monitoring merely because technology permits it. The objective is process evidence, not surveillance.

For younger learners or classroom contexts, teachers should use age-appropriate, transparent practices and applicable privacy rules. A stopwatch and six timestamps are often enough.

After review, discard detail that does not change teaching. Good observability reduces uncertainty; it does not maximise data collection.

Deep mock system 5 — Build a post-mock evidence board

Use four columns: stable strengths, recurring failures, uncertain findings and environmental notes. Every important observation belongs in one. This prevents uncertain interpretations from being written as facts.

Stable strength: “Protected revision occurred in three recent independent simulations.” Recurring failure: “Upper limits changed in three different texts.” Uncertain finding: “Later target language may deteriorate, but the final passage was also harder.” Environmental note: “Mock 2 used a different keyboard.”

The board should end with a decision column: preserve, repair, retest or ignore for now. Not every observation deserves intervention.

At the next mock, carry forward only unresolved and high-value items. Do not accumulate an endless archive of concerns that overloads the learner.

Deep mock system 6 — Distinguish readiness from familiarity

Familiarity can make a simulation feel easy. The learner knows the topic, genre, terminology and platform. Some familiarity is desirable—platform mechanics should be familiar. But source decisions need enough novelty to test transfer.

Label familiarity dimensions separately. Familiar platform plus unseen source is a strong representative condition. Familiar source plus unfamiliar platform measures something else. A known passage repeated under a new time target is a speed rehearsal, not an unseen readiness test.

Use this distinction when a result improves suddenly. Ask what became easier: the translation decisions or merely the environment? Both can represent legitimate learning, but they imply different next steps.

Readiness requires transfer to material not already solved. Familiarity should support execution without replacing the intellectual work.

Deep mock system 7 — Use repeated mocks without turning them into a league table

Repeated simulations are useful for within-learner patterns. They are less useful as casual rankings between learners because language pairs, source texts, prior knowledge, resource use and conditions differ. Keep the focus on each learner’s process.

A teacher can aggregate anonymous class patterns to plan instruction: many learners lose exceptions, research is sprawling, or final-task revision disappears. Avoid turning the mock ledger into public competition when the instructional purpose is diagnosis.

For an individual, compare dimensions rather than one total: completion, transfer accuracy, target-language quality, research discipline, revision durability and operational closure. A learner can improve on some while another remains stable.

Do not collapse these dimensions into an invented readiness score unless you have a validated assessment framework. Rich evidence is often more useful than a homemade number.

Deep mock system 8 — Know when the simulation is no longer the bottleneck

Eventually the learner may have a stable mock process. At that point, more simulation can have diminishing returns. Preparation may shift to maintenance, targeted language growth, official logistics and ordinary rest or scheduling decisions appropriate to the learner.

The mock system should be able to say “no full simulation needed today.” That is a sign of control, not laziness. Practice volume is not the objective.

If new evidence appears—a changed exam format, a newly recurring error, a long gap since representative practice—the value of another mock can rise again. The decision is dynamic.

Use the smallest practice format capable of answering the current question. This principle keeps the whole preparation system efficient.

Advanced mock analysis 1 — Completion is binary; readiness is not

A task is either complete enough to submit or it is not, but the evidence surrounding completion has dimensions. A learner can complete every task with weak revision, or complete every task with a stable quality system. Another can leave one line unresolved while demonstrating excellent control elsewhere. Do not reduce the whole analysis to “finished” versus “didn’t finish.”

Record completion first because it matters. Then inspect the cost of completion. Did the learner sacrifice source checking, target-language quality or resource discipline? Was the final task completed through unsupported guessing? The same binary outcome can arise from very different systems.

Conversely, an incomplete mock can reveal a process that is close to fitting the time. If one low-risk sentence remains after a strong revision routine, the repair differs from a mock with an entire missing task.

This richer view supports better planning without inventing a composite score.

Advanced mock analysis 2 — The error-location map

Place every consequential issue on two axes: task position and process phase where it likely entered. An omitted condition may enter during source reading, survive drafting and escape revision. A target-language error may enter during late reformulation. The map helps identify where prevention is cheapest.

If errors enter early but revision catches them reliably, the system has a functioning safety net. You may still improve first-pass quality, but the urgency differs from errors that enter and survive every layer.

If errors cluster only in Task 3, inspect position effects. If they cluster in every task around quotations, inspect quotation handling. Location across the session and location inside the translation process are complementary.

Do not pretend the entry phase is always knowable. Mark uncertain causation as uncertain. The purpose is to generate a testable repair hypothesis.

Advanced mock analysis 3 — The opportunity-cost ledger

Every extra minute spent on one task is unavailable elsewhere. After a mock, identify the three largest time overruns and ask what that time bought. Did it correct a central term? Resolve an ambiguous structure? Produce optional polish? Confirm an answer already supported?

Then identify what was lost downstream: revision, later-task reading, transition reset or final closure. This creates an opportunity-cost ledger.

Adrian spends eight extra minutes on a low-risk synonym and later has no time to verify two dates. The ledger makes the trade-off concrete. In the next attempt, the stopping rule can compare local benefit with global risk.

Not every overrun is waste. Eight minutes spent resolving a term that controls the entire passage may be justified. The ledger asks for consequence, not merely obedience to the schedule.

Advanced mock analysis 4 — The revision-yield map

For every revision phase, record what it caught: meaning, omission, quantity, reference, terminology, target-language clarity, mechanics or nothing. Over several mocks, you can see which checks yield important repairs.

If the number check repeatedly catches consequential issues, protect it. If a long style pass rarely changes anything, shorten or redesign it. If source comparison catches nothing because the learner is reading passively, teach an active mapping method.

Revision yield can also fall because first-pass quality improves. Distinguish that positive change from a weak check by auditing a few targets carefully after the timed attempt.

The goal is a lean safety system whose parts have demonstrated value for this learner.

Advanced mock analysis 5 — The support-dependence map

List which successful behaviours still depend on external support. Does the learner remember the research stop rule only when a teacher points to it? Do they perform a target-only review only when a checklist is visible? Do they identify source certainty independently?

Support is useful during learning. Readiness requires the relevant behaviour to survive under the intended independent conditions. Fade one support at a time and observe what changes.

Mira’s revision routine works with a printed checklist. She first shortens the checklist to four prompts, then to one heading, then removes it in an independent simulation. The behaviour remains. Support has successfully transferred into routine.

If behaviour collapses when support disappears, return to guided practice. Do not hide the dependence by leaving the support in a mock where it would not exist officially.

Advanced mock analysis 6 — The novelty map

Mark what was genuinely new in each mock: topic, genre, source construction, terminology family, platform behaviour or task sequence. A strong result across several novelty dimensions provides different evidence from repeated success on nearly identical material.

Do not maximise novelty all at once. A mock with an unfamiliar platform, new genre, specialist topic and new language direction may be so different that diagnosis becomes muddy. Change enough to test transfer while keeping the intended construct recognisable.

Use novelty strategically. If the learner’s platform routine is already stable, keep the platform familiar and vary the source. If you need to test a new official interface, use manageable language material so operational problems are visible.

Readiness is partly the ability to handle legitimate novelty without abandoning the trained process.

Advanced mock analysis 7 — The confidence-calibration review

Immediately after the mock, before detailed marking, ask the learner to identify three decisions they distrust and three they believe are strong. Later compare those judgements with review.

Low-confidence correct decisions can explain overresearch. High-confidence errors can reveal blind spots. Strong calibration can improve the return queue because the learner knows which uncertainty deserves attention.

Do not convert confidence into correctness. It is another signal. Teach the source features that should drive confidence: grammatical evidence, discourse relationships, authoritative terminology support and target-language usage.

Over several mocks, calibration can improve even before total error count changes. That is useful because better self-monitoring can support later independent correction.

Advanced mock analysis 8 — The next-action threshold

A finding should change the plan only when it is important enough and supported enough. One harmless stylistic difference may not cross the threshold. A repeated omitted negative does. An uncertain position effect may warrant another targeted observation before intervention.

Use three labels: act now, test again, monitor. Act now for consequential recurring or clearly understood failures. Test again for plausible but uncertain patterns. Monitor for low-consequence anomalies.

This prevents overreaction. A training plan that changes after every tiny fluctuation becomes unstable and makes later comparison impossible.

The threshold is not a mathematical formula. It is disciplined judgement about evidence, consequence and training cost.

Teacher system — Before the mock

The teacher’s first responsibility is to make the purpose explicit. Is this a teaching simulation, a representative rehearsal or an independent evidence-gathering mock? Tell the learner. The same passage can serve different purposes, but the interpretation must match the mode.

Verify that the learner knows the operational rules before the timer starts. A mock should not surprise them with an avoidable platform mechanic unless platform discovery is intentionally being tested. Provide official links for named credentials and distinguish local rules from provider rules.

Select material without targeting only the last lesson. If the learner knows every mock is secretly a quantifier test, recognition becomes cued. Representative simulations should sample the task family broadly.

Write the observation plan and one or two hypotheses. Then reduce teacher intervention. The mock belongs to the learner’s current independent system.

Teacher system — During the mock

Observe only what the design requires. Avoid facial reactions, hints and unsolicited corrections. Even a raised eyebrow can become a prompt in a small teaching setting.

If a genuine operational problem occurs—equipment failure, invalid material, incorrect instructions—record it. Decide whether the mock can continue and label the result accordingly. Do not hide compromised conditions.

For ordinary learner errors, wait. The point of independent simulation is to see whether the learner’s own monitoring catches them. Immediate correction belongs to guided practice.

Keep safety and wellbeing boundaries ordinary and humane. A training simulation is not worth continuing through a situation where stopping is clearly appropriate. Record that the session was interrupted rather than forcing a misleading result.

Teacher system — The first five minutes after the mock

Before marking, ask for the learner’s account. What felt expensive? Which decision remains uncertain? Where did the plan change? What do they think revision caught? This captures self-monitoring before external feedback reshapes memory.

Save the timed state. Then allow a short untimed self-review if useful. Mark changes in a different version. The difference between timed and self-corrected states reveals what the learner can repair independently when the clock is removed.

Do not announce a verdict from the doorway. “Good mock” or “bad mock” compresses too much information too early. Start with evidence.

If an official practice test supplies external feedback later, keep the immediate self-report so the two evidence layers can be compared.

Teacher system — Marking without preference inflation

Translation permits multiple defensible targets. Mark against source meaning, target-language quality, brief and the relevant official criteria where applicable. Do not penalise a learner merely for choosing a different acceptable wording from the teacher’s model.

When uncertain, classify the issue as unresolved for discussion rather than manufacturing certainty. Consult reliable references where needed. A teacher’s first intuition is evidence, not infallibility.

Separate preference from error in the feedback. This matters especially under time because learners who believe every preference difference is wrong may overedit future mocks.

Where using an official rubric, preserve its categories and terminology. Local diagnostic labels can sit beside it but should not pretend to replace the provider’s scoring system.

Teacher system — The repair conference

Choose the smallest number of issues capable of changing future performance. A mock can contain twenty corrections but only two training priorities. Start with consequential recurring failures and system bottlenecks.

For each priority, ask whether it is knowledge, process, integration or environment. Knowledge needs teaching. Process needs routines. Integration needs representative recombination. Environment needs operational rehearsal.

Write one next task for each priority and one behaviour to preserve. “Repair restrictive exceptions with fresh sentence contrasts; preserve the current revision checkpoint.” This creates continuity rather than total redesign.

End with a criterion for return to mock practice. The learner should know what evidence the component work is trying to produce.

Teacher system — Protecting learner agency

Mock evidence should inform the learner, not become a verdict about identity. Describe observed performance under specified conditions. “The final task lost its revision pass in this simulation” is precise. “You cannot handle long exams” overgeneralises.

Offer the evidence and possible next actions. Where multiple training routes are defensible, explain the trade-offs. The learner can participate in selecting the route, especially as they become more experienced.

Do not manufacture certainty about future results. A mock can improve preparation decisions without becoming a prophecy.

Agency is strengthened when the learner can explain their own process, understand the evidence and know what the next practice is designed to test.

Parent or mentor system — What to ask after a mock

Where a parent, mentor or non-specialist supporter is involved, keep the conversation process-focused. Ask what the mock revealed, what will be repaired, and what the next attempt is meant to test. Avoid turning one result into a prediction or comparison with another learner.

If the supporter does not know the source and target languages, they should not invent translation corrections. They can still help with schedule, representative conditions, logistics and preserving the learner’s agreed practice plan.

Encourage the learner to explain one improvement in plain language. Teaching the process back can reveal whether they understand the repair rather than merely following instructions.

Keep the next action finite. “Practise translation every night” is less useful than “complete two fresh exception-structure drills, then one timed paragraph before the next mock.”

Frequently asked questions about translation mock exams

How many mock exams should I do?

There is no universal number. Run enough representative simulations to answer system-level questions, but stop when another mock is unlikely to change the plan. Use component practice between mocks to repair known weaknesses.

Should every practice session be timed?

No. Untimed teaching, guided practice, retrieval drills and targeted repair are essential. Timing is added when you need to test performance under constraint.

Does passing a practice test mean I will pass the real exam?

No guarantee follows from a practice result. Even NAATI explicitly states that passing its assessed practice test does not guarantee passing the actual test. Treat practice as evidence for preparation, not certainty about a future outcome.

What if my mock score drops?

Compare conditions and error patterns before concluding that ability declined. The material may be harder, the environment may differ or a new weakness may have been exposed. Diagnose the change.

Should I repeat the same mock?

Repeating can be useful for rehearsal or checking a revised process, but the passage is no longer unseen. Label the evidence accordingly. Use fresh material when you need transfer evidence.

Should I use machine translation during a mock?

Only if the practice condition you are intentionally simulating permits it. For a named assessment, follow the current official resource rules. Tool-assisted learning outside the mock should be labelled separately from independent performance.

What if I finish much earlier than the time limit?

Use your planned checks and unresolved-risk queue. If the target remains strong after meaningful review, early completion is useful evidence. Do not manufacture edits simply to fill time.

What if I cannot finish?

Preserve the incomplete timed state, finish untimed for learning, then diagnose the bottleneck. The next step may be knowledge repair, research discipline, pacing or a more generous training condition before returning to representative timing.

Should a teacher mark every stylistic difference?

No. Distinguish genuine target-language problems from defensible alternatives and preference. Overcorrection can teach unnecessary hesitation.

Can a homemade mock be useful?

Yes, if it is well designed and honestly labelled. It can test timing, integration and transfer. It should not be represented as official material or used to invent unsupported pass probabilities.

A 16-session mock-exam development cycle

This is a flexible sequence, not a mandatory calendar. Repeat, remove or spread sessions according to evidence.

Session	Purpose
1	Independent timed component baseline
2	Repair largest component bottleneck
3	Fresh transfer check
4	Second timed component
5	Build mock specification and fidelity audit
6	Full Mock 1
7	Product/process review
8	Targeted repair A
9	Targeted repair B
10	Fresh transfer tests
11	Transition or revision durability lab
12	Full Mock 2
13	Compare conditions and recurrence
14	Repair or preserve—whichever evidence requires
15	Representative retest
16	Full Mock 3 only if a system-level question remains

The important feature is the space between mocks. Simulation produces information; the intervening sessions use it. A schedule of Mock 1, Mock 2, Mock 3 without repair can become repeated measurement of the same state.

If Mock 1 is already strong and no meaningful system-level uncertainty remains, skip ahead. If Mock 1 exposes a deep language gap, spend longer in repair before Mock 2. The cycle bends around evidence.

The final translation mock dashboard

Dimension	Record	Question
Fidelity	Task/time/resources/environment	What did this mock actually simulate?
Completion	Tasks finished / unresolved	Did all required work reach submission state?
Transfer	Consequential meaning issues	What source distinctions changed?
Target language	Clarity/register/mechanics	Did quality hold across the session?
Research	Episodes and yield	Which searches changed decisions?
Pacing	Task and phase times	Where did the plan diverge?
Transitions	Early-task errors	Did previous context contaminate the next task?
Revision	Time + catches	Did the safety system survive?
Support	Guided/supported/independent	What help was required?
Next action	Preserve/repair/retest/mock	What is the smallest useful next task?

Do not convert the dashboard into a league table. It is a control surface for the learner’s own preparation. The most important field is the last one because measurement has value only when it improves action.

The handoff from mock exams to final preparation

When repeated representative work shows a stable process, final preparation becomes less about discovering a new system and more about preserving the one that works. Keep official rules current. Maintain language retrieval. Use targeted checks for any remaining known weakness. Avoid introducing unnecessary machinery simply because the date is close.

If a late mock exposes a clear problem, repair it at the smallest useful scale. Do not automatically respond with another full mock the next day. The right response depends on the mechanism.

Translation mock exams are therefore not the end of preparation. They are observability points inside it. Their job is to show whether the complete system behaves as intended and, when it does not, to tell you where to look next.

A mock is valuable when it changes the next decision for a good reason.

Extended practice 1 — Design a mock that can fail informatively

A useful mock should be capable of revealing different failure modes. If every passage is easy, every resource is familiar and time is generous, the simulation may confirm comfort without testing the system. If the mock is absurdly difficult, failure becomes inevitable and diagnosis weak. The useful zone contains realistic variation and enough challenge for the trained routines to matter.

Design each locally created task with one or two ordinary stressors rather than every stressor at once. One passage may contain dense reference chains. Another may contain numbers and conditions. Another may require more target-language register control. Across the session, the system encounters a representative mix.

Do not tell the learner which stressor belongs to which task. The ability to recognise what deserves attention is part of translation competence. Afterward, compare the designer’s intended challenge with the learner’s actual bottleneck. They may differ.

If the mock produces no useful variation across several attempts, adjust the material portfolio rather than shortening the time arbitrarily. Difficulty should come from relevant translation decisions, not punishment.

Extended practice 2 — Build a mock from mechanisms, not topics

Topic labels are convenient but can hide the decisions inside a text. “Environment” can be easy or difficult. “Education” can contain complex institutional roles, percentages and exceptions. Build mock coverage around mechanisms as well as topics.

Create a matrix with rows for passages and columns for reference, modality, quantity, terminology density, discourse structure, cultural specificity and target genre. You do not need numeric ratings. Mark presence and notable concentration.

When selecting a set, avoid three passages that all test the same mechanism accidentally. Likewise, do not force every mechanism into every mock. Over several simulations, the portfolio should expose the learner to legitimate breadth.

This makes post-mock interpretation stronger. If reference errors recur across different topics but always in high-reference passages, the mechanism becomes clearer.

Extended practice 3 — Separate platform readiness from translation readiness

A learner can know the language and still lose time to the platform. Another can operate the platform smoothly while making translation errors. Train and measure these dimensions separately before combining them.

Run a platform-only rehearsal where the learner enters dummy text, switches input methods, accesses permitted resources and submits according to the official or representative procedure. No difficult translation is needed. Operational friction becomes visible.

Then run a language-rich task in a familiar environment. If performance differs, you have separated two costs. The later full mock tests whether both now coexist successfully.

Provider preparation modules are especially valuable here because they can expose the actual environment without consuming official examination time. Use current official materials where available.

Extended practice 4 — Build a revision task as its own skill

Where an assessment includes a separate revision task, do not assume a good translator automatically performs it well. Revision requires identifying problems in another target, distinguishing error from acceptable variation and making justified changes without introducing new ones.

Practise on targets containing mixed issue types: clear meaning error, awkward language, defensible alternative and preference-only difference. The learner must decide what deserves intervention.

Add time only after the judgement is reliable. A fast reviser who changes acceptable alternatives unnecessarily may be less effective than a slower reviser with better intervention thresholds.

Then place the revision task after translation work to test switching. The learner must move from producing their own target to evaluating another target. That mode change can be trained.

Extended practice 5 — Use a delayed review

Immediate review catches fresh memories of the process. Delayed review, perhaps the next day, can reveal whether the target stands on its own once the source decisions are less active in memory. Use both occasionally.

In the immediate review, capture process explanations: “I chose this term because…” In the delayed review, read the target afresh for coherence and target-language quality. Then compare.

A sentence that felt natural during the mock may look source-shaped later. Conversely, a sentence the learner distrusted may prove perfectly acceptable. This comparison improves confidence calibration.

Do not delay all feedback when a misconception needs prompt correction. Delayed review is an additional lens, not a universal teaching rule.

Extended practice 6 — Build a mock archive that remains interpretable

For each mock, store the specification version, source identifiers or provenance notes, timed target, corrected target, process trace, external feedback if any, diagnostic summary and next action. Keep the archive compact enough to use.

Do not store protected official content in ways that violate provider terms. A link or identifier may be sufficient. The archive’s purpose is the learner’s evidence trail, not redistribution.

After several mocks, review the summaries rather than rereading every page. Which failures disappeared? Which strengths remained? Which uncertainty is still open? The archive becomes a longitudinal map.

Archive design matters because memory is selective. Without records, learners can remember one dramatic bad mock and forget three stable ones, or remember a strong score and forget the support conditions.

Extended practice 7 — The mock after a long break

If substantial time has passed since the last representative simulation, do not assume the old process is still automatic. Begin with a short refresher of official rules and one timed component. If the component is stable, proceed to the full mock.

The first post-break mock should be interpreted partly as reactivation evidence. Slower platform use or forgotten routines may recover quickly. Separate temporary rust from deeper knowledge loss by retesting after a small amount of practice.

Do not compress the time below official conditions to compensate for the break. Restore the normal system first. Training should recover reliability before adding difficulty.

Evidence freshness is not a demand for constant testing; it is a reminder that old performance has a date.

Extended practice 8 — The mock after a major repair

A major repair changes the system enough that earlier mock comparisons need context. Suppose the learner adopts a new research workflow or substantially changes first-pass reading. The next mock is partly a validation of the new architecture.

Keep other conditions as stable as practical so the effect of the repair is easier to inspect. Do not simultaneously change passage type, platform, time target and resource set unless the real assessment requires those changes.

Review both intended and unintended effects. Research time may fall while target terminology becomes less consistent. Initial reading may grow longer while revision becomes shorter. A system change can redistribute cost.

Preserve the new method only if the whole performance remains defensible. Local speed gains are not enough.

Extended practice 9 — The mock that reveals nothing new

Sometimes a simulation confirms the existing picture: same strengths, no recurring failure, representative completion and no new operational issue. That is still evidence. It may support the decision to stop changing the process.

Record “no new actionable finding” rather than inventing one. The next session can be lighter maintenance, language enrichment or logistics rather than another diagnostic campaign.

If several mocks reveal nothing new, the marginal value of further simulation is low until conditions change. Protect the learner’s time.

Preparation quality is not proportional to the number of full papers completed. It is proportional to whether practice produces and acts on useful evidence.

Extended practice 10 — The mock that goes unexpectedly badly

When a normally stable learner has one poor simulation, preserve the evidence before explaining it. Was the material representative? Were there operational problems? Was the task unfamiliar? Did a known weakness recur? Did the process break at a specific point?

Avoid global conclusions from one event. Run a targeted check of the suspected component. If the weakness reproduces, repair it. If the component is clean and the mock contained unusual conditions, record the anomaly and monitor.

This protects against both complacency and overreaction. A bad mock can matter without becoming a prophecy.

Return to representative simulation only when the unresolved question is again system-level.

Final workshop 1 — From one mock to a one-page action plan

After review, compress the mock into one page. At the top, write the conditions. Then write three strengths to preserve, no more than three repair priorities, the evidence for each, the next task and the condition for returning to full simulation.

This compression prevents a long marking document from becoming the plan. Corrections explain the past; the action page controls the future.

For example: preserve passage scan, resource stopping and target-only review. Repair conditional exceptions and Task 3 numerical checking. Next tasks: six exception contrasts, one unseen paragraph, three-task revision-durability drill. Return to mock when both survive fresh timed work.

Put low-priority stylistic notes in a separate learning list so they do not crowd the performance plan. Not every correction deserves equal scheduling.

At the next mock, bring the old action page only after the attempt. Do not cue the learner with the expected traps unless that is intentionally part of the practice mode.

Final workshop 2 — From three mocks to a trajectory

With three reasonably comparable mocks, you can describe a trajectory without pretending to forecast. Look for direction in completion, revision survival, recurring error families, research yield and independence. Note where conditions differ.

A trajectory can be mixed. Completion may stabilise while target-language quality improves and one source-language blind spot remains. Write the pattern in words rather than forcing a single upward or downward score.

Use cautious language: “Across the last three independent simulations, revision time remained protected and quantity-boundary errors fell after targeted practice; attribution errors appeared once and are being monitored.” This statement is informative and proportionate.

Do not extrapolate the trajectory into an exam probability. The mocks are preparation evidence, not a crystal ball.

If the trajectory is stable and the remaining findings are low consequence or varied, shift from redesign to maintenance. If one recurring failure remains, return to targeted repair.

Final workshop 3 — Build the learner’s self-debrief

The learner should eventually be able to debrief without waiting for the teacher. Give them five prompts: What worked? Where did the plan change? What error or uncertainty mattered most? What caused it? What is the smallest useful next practice?

At first, compare the learner’s debrief with the teacher’s. Where do they agree? Where does the learner overfocus on style or undernotice meaning? Teach the review process itself.

Over time, fade teacher prompts. A learner who can inspect their own evidence becomes less dependent on external correction between sessions.

Self-debrief should remain evidence-based. “I felt terrible” is real experience but does not by itself tell you whether the target deteriorated. “I felt rushed after Task 1, and the trace shows Task 2 started twelve minutes later than planned” connects experience to evidence.

This is metacognition in service of action, not introspection for its own sake.

Final workshop 4 — Build the last representative rehearsal

When a final full rehearsal is useful, keep it representative rather than punitive. Use current rules, unseen appropriate material, the intended resource set, familiar platform procedures and the timing architecture already trained.

Do not deliberately choose the hardest passages in the archive “to be safe.” A rehearsal should sample the intended task, not create an unofficial super-exam.

Afterward, perform the normal review but resist unnecessary system changes if the process is stable. Late discovery of a narrow issue calls for narrow repair. Late discovery of a major official-format change calls for operational adaptation.

Record the rehearsal date and conditions. Then move attention away from constant measurement if further simulation is unlikely to add value.

The last rehearsal is not a prophecy. It is the freshest integrated evidence available to inform final preparation.

Final workshop 5 — Protect the difference between practice and the real assessment

No local simulation can recreate every feature of a real high-stakes assessment. The actual source material is unknown. The psychological context differs. Provider systems and marking are external. Honest preparation accepts this gap rather than claiming perfect replication.

The goal is sufficient representativeness: train the decisions and operational routines likely to matter, expose the learner to legitimate variation and build a process that can adapt when the exact text is new.

This is why transfer matters so much. If the learner succeeds only on rehearsed material, the mock has taught familiarity. If the process survives unseen variation, the evidence is stronger.

Keep uncertainty where it belongs. Preparation can become excellent without becoming omniscient.

Final workshop 6 — What to do when the official practice test exists

Use official practice according to the provider’s current guidance because it can offer task, platform and scoring fidelity that local material cannot. Prepare enough beforehand that the official practice generates useful evidence rather than being consumed by avoidable unfamiliarity.

Afterward, preserve the provider’s feedback exactly. Add your own process trace and diagnostic notes beside it. Do not rewrite official categories into local ones and then claim equivalence.

If official feedback identifies a weakness, repair it with fresh local tasks. Do not repeatedly purchase or repeat official practice merely to chase a different result unless that use is appropriate and permitted.

Where official materials are unassessed, use them for familiarity and self-review without pretending they carry assessed evidence.

The provider owns the credential. Your training system owns the learning loop around it.

Final workshop 7 — What to do when no official mock exists

Build from published specifications and legitimate sample information. Use original or appropriately licensed passages that resemble the broad task family. State clearly what is inferred and what is known.

Do not reverse-engineer confidential exam content or present invented passages as leaked or official material. Representative training does not require misrepresentation.

Seek competent bilingual review where possible. If no external marker exists, focus claims on observable process and identified translation issues rather than declaring a pass.

Over several locally created simulations, vary material and keep conditions stable enough to observe patterns. The absence of official mocks increases the importance of honest boundaries.

Final workshop 8 — The handoff to examination day

By the end of mock training, the learner should not need a giant mental script. The core should be compact: understand the task, inspect the work, allocate the clock, translate with bounded uncertainty, protect revision, recover when necessary and submit cleanly.

The mock archive has already done the analytical work. Examination day is not the time to reread every past error. Use the familiar process and the official current instructions.

New source material will create new decisions. That is expected. The purpose of preparation was not to predict the text but to build a system capable of meeting unfamiliar text without abandoning fidelity.

After the real assessment, the result belongs to the provider. Until then, preparation evidence can guide choices without pretending to know the outcome.

Decision library — If the mock runs out of time

First preserve the timed state. Then locate the first meaningful divergence from plan. Do not begin with the final unfinished sentence; the cause may have started an hour earlier. Inspect task selection, early research, first-draft completion, transitions and revision allocation.

Ask whether the overrun is local or systemic. One unusually difficult sentence is local. Every task exceeding its allocation suggests a broader process or knowledge issue. A single mock cannot always distinguish them, so use a short retest.

Finish the incomplete work untimed for learning. Compare the additional time required and what it was used for. If the remaining work is mostly target-language polish, the problem differs from unresolved source comprehension.

Choose the smallest repair and do not shorten the next clock automatically. Re-establish a reliable process before further compression.

Decision library — If the mock finishes early

Check whether planned revision was genuinely completed. Inspect unresolved flags, high-risk facts and target-language clarity. If meaningful checks remain, use the time. If the target is clean, preserve the early finish as evidence.

Do not automatically make the next mock shorter. The real assessment time may be fixed, and the useful next challenge may be material variation rather than artificial compression.

If several representative mocks finish early with stable quality, investigate whether the material is too easy or familiar. Increase representativeness before increasing pressure.

Early completion is one dimension of performance, not a readiness verdict by itself.

Decision library — If the first task is much worse than later tasks

Inspect the start routine, passage selection and entry into the environment. The learner may need time to settle into the source, or the first task may simply be harder. Compare across another mock before attributing a stable warm-up effect.

Use a short pre-mock orientation routine that is permitted and representative: verify the environment, read instructions and begin. Do not add unrelated warm-up content if the real assessment would not allow it.

If first-task errors cluster around rushed reading, protect orientation. If they cluster around platform mechanics, train the platform. If they do not recur, monitor rather than redesign.

The position pattern is a clue, not a diagnosis.

Decision library — If the final task is much worse

Compare remaining time, task difficulty and revision behaviour. A late task may be worse because earlier tasks borrowed its time, because its source is harder, or because sustained attention and target-language quality are less durable.

Run a durability mini-simulation with balanced tasks. If the same late degradation appears, train the affected component after sustained work. If it disappears, the original passage may have been the main cause.

Do not solve a late-task problem by making the first tasks careless. Improve whole-session allocation and the specific late-session routine.

Protect a global reserve where the assessment format allows it so one early overrun does not silently eliminate final checking.

Decision library — If research dominates the mock

List the research questions and whether each lookup changed the target. High volume can mean unfamiliar terminology, weak source comprehension, poor resource routing or reassurance search. Do not assume the same cause for every learner.

For recurring terms, build prior knowledge. For bounded institutional questions, use authoritative sources. For context questions, read the paragraph before searching. For reassurance, train stopping criteria.

Retest on new terms. Efficient research is the ability to route an unfamiliar question, not memorise the old answer.

Keep official resource restrictions central. A mock should not reward a search workflow unavailable in the intended assessment.

Decision library — If revision catches many serious errors

This is both good and bad evidence. Good: the safety net works. Bad: first-pass reliability may be low. Preserve revision while moving recurring checks earlier.

If revision repeatedly catches negatives, train negation during source reading. If it catches terminology inconsistency, improve term control during drafting. The final sweep remains as backup.

Measure whether the number of serious catches falls after repair while total quality stays stable. Then revision may become faster naturally.

Do not remove the safety net just because it is doing a lot of work. That would hide rather than solve the first-pass problem.

Decision library — If revision catches nothing

Three explanations are possible: the draft is strong, the check is weak, or the mock is too easy. Audit a few targets carefully after time. If external review finds issues the timed revision missed, improve the checking method.

If careful review also finds no consequential issue across varied material, the routine may be effective and first-pass quality strong. Preserve it.

If only stylistic alternatives remain, do not manufacture corrections to justify revision time. A quiet safety system can still be valuable.

Use evidence before cutting the reserve.

Decision library — If teacher feedback and learner confidence disagree

Inspect the exact decisions. A learner may distrust a correct unfamiliar term while being confident about a wrong familiar construction. Explain the evidence behind the feedback rather than demanding trust.

Where the teacher’s judgement is itself uncertain, consult reliable sources or another competent reviewer. Translation evaluation contains legitimate alternatives.

Build calibration drills from the disagreement. The learner predicts, translates, reviews evidence and updates confidence. Over time, uncertainty can become better targeted.

The goal is not obedience to the marker; it is stronger evidence-sensitive judgement.

Decision library — If two mocks contradict each other

Compare conditions before choosing which one to believe. Passage difficulty, familiarity, support, platform and timing may differ. The contradiction may be real variability rather than bad data.

Identify the dimension that changed most. Run a targeted third observation that controls it where practical. If Mock 1 had familiar terminology and Mock 2 did not, test an unfamiliar but representative timed passage.

Do not average away a meaningful instability. If performance swings widely under comparable conditions, robustness itself becomes a training question.

Contradictory evidence is an invitation to narrow the question.

The translation mock exam as a control loop

The deepest purpose of a mock is not rehearsal alone. It closes a control loop between the learner’s internal process and observable performance. Before the simulation, you have a model of readiness. During the simulation, the system acts under constraint. Afterward, the target, trace and feedback return evidence. The preparation plan is then updated.

If the return evidence does not change anything, either the system is stable or the review is too weak. Distinguish those possibilities. A stable system deserves preservation. A weak review needs better observation.

This loop prevents two extremes. One is endless preparation without testing integration. The other is endless testing without learning. Good mock practice alternates measurement and intervention.

The loop also keeps confidence grounded. Confidence can rise because representative performance is stable, not because the learner has completed an impressive number of papers.

The minimum viable mock

When time or material is limited, build the smallest simulation that still tests the unresolved system question. If you need to test task switching, two back-to-back tasks may be enough. If you need to test revision durability, three shorter tasks can be better than one long paper. If you need to test the full official time architecture, only a full representative session will answer it.

This principle avoids unnecessary cost. A mock is a tool, not a ceremony. Its size should match the question.

Label the reduced simulation honestly. “Two-task transition mock” is better than pretending it reproduces the whole examination. The evidence remains valuable because its scope is clear.

As the examination approaches, minimum viable mocks can maintain specific routines without repeatedly consuming a full session.

The maximum useful mock

A mock becomes too large when additional difficulty no longer represents the assessment and begins to obscure diagnosis. Adding extra passages, shorter time, prohibited resources and unfamiliar software simultaneously may create a heroic challenge but poor evidence.

Use the official or educational target as the ceiling for representativeness. If you want to stress-test one dimension, change it deliberately and keep the others stable.

A harder-than-real training condition can sometimes have a purpose, but it should be named as stress practice rather than treated as a more valid readiness test. More difficulty is not automatically more fidelity.

Good simulation is disciplined imitation of relevant constraints, not maximal suffering.

The mock-result conversation with yourself

After a mock, write four sentences. “Under these conditions, I completed…” “The strongest evidence was…” “The most important unresolved issue is…” “My next practice will test…” This forces scope and action.

Avoid identity statements such as “I am bad at translation” or “I am definitely ready.” Replace them with observable claims. The language of the review shapes the quality of the plan.

If the result is strong, name the process that produced it. If the result is weak, name the decision that needs repair. Both responses preserve agency.

Return to the four sentences after the next attempt. Did the unresolved issue change? Did the planned test answer the question? The review itself becomes cumulative.

What this article deliberately does not own

It does not own general mock-exam theory across all subjects; How Mock Exams Fail already covers that wider territory. It does not own the full translation curriculum; Translation Exam Preparation does. It does not own worked translation passages; Translation Exam Practice does.

It does not own component time management; Timed Translation Tests does. It does not own general study evidence freshness, planning or practice testing, though it links those concepts where they become necessary inside translation simulation.

Its canonical job is narrow and substantial: run the complete translation system under representative simulated conditions, interpret what returns, and use that evidence to choose the next preparation action.

Keeping ownership explicit protects the wider eduKateSG estate from cannibalisation while allowing the articles to function as one connected learning system.

Official references and scope note

This is independent educational content. It is not official preparation material from ATA, NAATI or CIOL. Assessment formats, permitted resources, fees, platforms and policies can change. Always verify current requirements with the administering organisation.

American Translators Association. Taking and Preparing for the ATA Certification Exam and its current certification resources. Used to ground references to the present online exam and representative preparation.

NAATI. Certified Translator, Candidate Instructions, and Certified Translator Preparation Module. Used to ground references to current task structure, assessed versus unassessed practice and platform preparation.

Chartered Institute of Linguists. Diploma in Translation. Linked as a separate qualification with its own current assessment information.

Next lane handoff: after mock simulation and readiness evidence, the next translation examination article can own final examination-day execution without recreating this mock architecture.

Twenty mock-exam scenarios and the evidence each one produces

The scenarios below are not scripts to copy mechanically. They show how changing one condition changes what a mock can tell you.

Scenario 1 — First independent full simulation

Use representative unseen material, intended resources and full timing after component practice has become reasonably stable. The main evidence is integration: whether reading, drafting, research and revision coexist across the session. Do not expect the first full simulation to answer every readiness question.

Scenario 2 — Full simulation after a research repair

Keep the time and resource environment stable. Use unfamiliar terminology so the new stopping rules are genuinely tested. Record research episodes and revision time. The key question is whether research became cheaper without reducing terminology quality.

Scenario 3 — Full simulation after a source-reading repair

Use passages containing the repaired structure among ordinary material. Do not announce where it appears. The mock asks whether recognition survives task switching and the clock.

Scenario 4 — Two-task transition mock

Use two short texts with different genres and terminology fields. The primary evidence is the first few minutes after the switch. This reduced mock is cheaper than a full session when transition contamination is the only unresolved question.

Scenario 5 — Revision durability mock

Run several shorter tasks back-to-back and require the full checking routine on each. Compare revision time and yield by position. This isolates whether the safety net survives cumulative work.

Scenario 6 — Platform-familiarity mock

Use manageable language material in the actual or representative interface. The objective is operational fluency: input methods, navigation, permitted resources and submission. Do not interpret an easy source as strong language readiness.

Scenario 7 — Unfamiliar-domain mock

Use a legitimate but less familiar topic within the intended task range. The evidence concerns research routing, context use and process robustness under novelty. Avoid specialist material outside the assessment’s construct.

Scenario 8 — Familiar-domain control mock

Use a familiar topic with unseen wording. If performance improves sharply relative to unfamiliar-domain work, domain knowledge may be carrying a meaningful part of the timing difference. That is useful for planning breadth.

Scenario 9 — Passage-choice mock

Where the assessment permits choice, provide representative alternatives. Record selection time and whether the chosen passage’s risk was predicted accurately. Review rejected passages afterward to calibrate the selection heuristic.

Scenario 10 — No-choice risk-scan mock

Where no passage choice exists, use one assigned source and ask the learner to perform the trained whole-text risk scan. The evidence concerns attention allocation rather than selection.

Scenario 11 — Recovery mock

Introduce a known small time deficit or a deliberately longer first task. The learner practises rebasing the plan. Review what was sacrificed and whether high-consequence checks survived. Do not use this as the normal readiness condition.

Scenario 12 — No-change control mock

After a strong simulation, preserve the process and change only the unseen material. Stable performance supports robustness. A sharp change directs attention to text variation before process redesign.

Scenario 13 — Post-break reactivation mock

After a long gap, begin with a component refresher and then run a representative session. Interpret slower mechanics cautiously. A second short check can distinguish temporary rust from deeper loss.

Scenario 14 — Target-language durability mock

Select passages whose source comprehension is manageable but whose target genres differ. The question is whether natural, appropriate target language remains stable across switching and time.

Scenario 15 — Numerical-risk mock

Use representative texts containing quantities, dates and populations without making every sentence numerical. The learner should recognise and protect the relationships without being cued that numbers are the hidden lesson.

Scenario 16 — Attribution-and-certainty mock

Include observation, reported opinion, possibility and limitation across different tasks. The evidence is whether epistemic strength remains faithful late in the session.

Scenario 17 — Resource-restriction mock

Use only the resources permitted by the intended assessment. Compare with earlier supported practice. The difference shows how much performance currently depends on unavailable tools and where prior knowledge should be strengthened.

Scenario 18 — Official-practice integration

When an official assessed or unassessed practice product is available, use it according to provider guidance. Add your process trace without altering official conditions. Keep provider feedback distinct from local analysis.

Scenario 19 — Final representative rehearsal

Use current rules, unseen appropriate material and the familiar process. The purpose is fresh integrated evidence and logistics confirmation, not maximal difficulty. Avoid redesigning the system afterward unless the evidence clearly requires it.

Scenario 20 — The mock you decide not to run

If the unresolved problem is already known and local, choose a targeted task instead. Record the decision: “Full mock deferred because reference-chain transfer still fails in timed paragraphs.” Not running a low-value simulation is part of intelligent preparation.

A mock-exam evidence hierarchy

Different evidence sources answer different questions. Use them together rather than treating one as absolute.

Evidence	Strongest use	Limitation
Official assessed practice	Provider-aligned task/feedback evidence	Still not a guarantee of future result
Official unassessed preparation	Format/platform familiarity	May not provide external scoring
Independent representative local mock	Process integration and recurring patterns	Local material/marking may differ
Timed unseen passage	Component performance under time	Does not test whole-session integration
Guided practice	Learning and scaffolded correction	Not independent readiness evidence
Untimed repair	Knowledge and best-quality reasoning	Does not show timed execution

Evidence strength depends on the claim. Untimed repair is excellent evidence that a learner can understand a structure with time, but weak evidence that they can execute it under a three-hour assessment. An official platform module is strong for interface familiarity but may not answer translation-quality questions.

Ask what claim you are trying to support, then choose the evidence source whose conditions match it.

How to write a defensible mock conclusion

A good conclusion contains condition, observation, limitation and action. Condition: “In an independent three-task simulation using the current local specification…” Observation: “all tasks were completed with a protected revision phase, while two attribution errors appeared in the final task.” Limitation: “the final passage was also the most syntactically dense, so a pure position effect is not established.” Action: “retest attribution after sustained work before changing the whole pacing system.”

This format prevents both overconfidence and vagueness. It says what happened without pretending to know more than the evidence supports.

For a strong result: “Across two recent representative independent simulations, the current process completed all required tasks within the intended window, revision remained intact, and no recurring consequential transfer error was identified. This supports preserving the process while varying material; it does not guarantee an external examination result.”

For a weak result: “The simulation was incomplete because Task 1 research consumed substantially more time than planned. Post-test review showed several searches did not change the target. The next step is bounded research practice before another full mock.”

Write conclusions like engineering notes, not motivational slogans. Clear evidence makes encouragement more credible because it is attached to something real.

How to prevent mock-score obsession

A score is attractive because it compresses complexity. That compression can be useful when the score comes from a valid assessment system, but preparation still needs to know what produced it. Keep the score at the top of the record if relevant, then immediately unpack process and error evidence.

Do not make every training conversation about whether the number rose. A learner can improve research discipline and revision durability while encountering a harder passage that produces a lower score. Those process gains may matter for future robustness.

Likewise, a higher score can hide a deteriorating process if the material is easier or familiar. The mock dashboard protects against this by preserving conditions and mechanisms.

If score discussion is crowding out learning, temporarily conduct the diagnostic review before revealing the number. Then integrate both.

How to use models and reference translations after a mock

A model translation is a comparison object, not a single answer key unless the assessment specifically treats it that way. Compare meaning decisions, terminology, structure and target-language naturalness. Ask why the model differs.

Classify differences: your target is wrong, the model is stronger, both are defensible, or the difference is preference. This protects the learner from rewriting every sentence to match the model’s surface wording.

Where a model reveals a useful target-language pattern, extract the pattern and practise it in fresh sentences. Where it reveals a source misunderstanding, teach the source construction.

Do not use a model before the timed attempt when the goal is independent evidence. That turns the simulation into guided reproduction.

How to use AI after a mock without corrupting the evidence

AI tools can be useful in ordinary learning for generating contrast examples, brainstorming alternative target formulations or helping organise an error ledger, subject to the learner’s context and applicable rules. They should not be used during a mock that is intended to simulate conditions where such tools are not permitted.

Preserve the timed human target first. Then, if using AI after the attempt, compare outputs critically. An AI suggestion is not automatically correct, authoritative or contextually appropriate. Verify terminology and source meaning with reliable evidence.

Use AI to create fresh practice rather than merely fix the old answer: “Generate five sentences contrasting permission and obligation in this source language” can support a drill. A competent teacher or bilingual reviewer should still inspect important educational material where accuracy matters.

Label tool-assisted repair separately. The mock evidence remains the unassisted or permitted-resource state you originally saved.

How to know whether a repair has become automatic enough

A repair begins explicit. The learner may need a written prompt: check every quantity boundary. With repetition, the check becomes quicker. Later, the learner notices the boundary during ordinary reading and the explicit prompt adds little.

Test automaticity by removing the prompt in fresh material. If performance remains stable, the scaffold can fade. Then test after a task switch or later in a mock. Automaticity must survive context change, not just one comfortable paragraph.

Do not require zero conscious effort. Difficult source material will always demand attention. The question is whether the repaired routine still consumes disproportionate working time or whether it has become part of normal processing.

When the scaffold fades successfully, simplify the mock checklist. A mature system becomes smaller.

How to preserve uncertainty without freezing

Translation includes decisions where evidence is incomplete or alternatives remain. A mock tests whether the learner can carry uncertainty without either pretending certainty or becoming immobilised.

Use provisional decisions with return points. Rank unresolved units by consequence. Research within the permitted environment. If evidence remains mixed, select the best-supported defensible target and continue. After the mock, investigate more deeply.

The ability to finish under uncertainty is not carelessness. It is controlled closure under finite resources. The opposite extremes—unsupported guessing and endless searching—both damage performance.

Mocks are particularly useful here because they reveal whether uncertainty management still works when several tasks compete for time.

How to preserve the learner after the mock

A long simulation can generate a large correction list. Do not hand the learner forty equal failures. Organise feedback into evidence, priorities and next actions. Preserve successful behaviours explicitly.

Use neutral language about the attempt. “This source relationship changed” is more useful than a character judgement. The learner needs a map they can act on.

Schedule repair realistically. One or two high-value changes implemented well can improve the next mock more than an enormous checklist that is never practised.

The mock belongs inside education. Its purpose is to make future performance more controllable, not to create a second examination culture around practice.

A compact final checklist for the mock designer

• Current task specification verified.
• Purpose of this mock stated.
• Material unseen or familiarity labelled.
• Task difficulty representative rather than punitive.
• Permitted resources matched.
• Platform or environment appropriate.
• Support level declared.
• Observation plan minimal and sufficient.
• Timed state will be preserved before correction.
• Product and process will be reviewed separately.
• Recurring errors will outrank preference differences.
• Next action will be chosen from evidence.

If these conditions are satisfied, the mock has a good chance of producing useful information even when the target itself contains errors. A simulation does not need to flatter the learner to be successful.

A compact final checklist for the learner

• Know the current rules of the assessment you are simulating.
• Use the process already trained.
• Read the brief before committing.
• Allocate time across the whole session.
• Do not let one hard unit silently own the paper.
• Research questions, not anxiety.
• Complete a defensible first target before optional polish.
• Protect revision.
• Reset when the task changes.
• Recover from overruns using the time that remains.
• Submit deliberately.
• Save the timed state and learn from it afterward.

The checklist should eventually feel familiar enough that it does not need to be visible. Practice exists to move control from the page into behaviour.

The anatomy of a useful post-mock error

An error becomes useful when it can be described at several levels. Surface: what did the target say? Source relationship: what should have survived? Mechanism: why might the change have occurred? Process location: when could it have been prevented or caught? Transfer task: what fresh practice will test the repair?

Example: the source says applications received after 5 p.m. will be processed the next day. The target says applications received by 5 p.m. will be processed the next day. Surface difference: after becomes by. Relationship: temporal boundary reversed. Mechanism hypothesis: the learner treated the phrase as a familiar deadline expression. Process location: source reading and final date/time sweep. Transfer task: fresh before/after/by/until contrasts inside notices.

This anatomy moves feedback beyond “wrong preposition.” It identifies the meaning relation and gives the next practice a job.

Do not force a mechanism when you do not know it. Ask the learner what they believed. If uncertainty remains, write two hypotheses and design a discriminating task.

The anatomy of a useful post-mock strength

Strengths deserve the same specificity. “Good translation” is too broad. Identify the behaviour: “The learner used context before external research in three ambiguous units and preserved revision time”; “The transition reset prevented terminology carryover”; “The target-only pass caught two source-shaped sentences without changing meaning.”

Then ask whether the strength is stable, newly learned or condition-dependent. A new strength may need another transfer test. A stable strength should be preserved without extra scaffolding.

Specific strengths help the learner know what not to change. This is especially important after a mixed mock where one weakness can dominate attention.

Teaching is partly selection. Preserve high-value routines so repair work does not accidentally displace them.

How to build discriminating follow-up questions

When several causes could explain the same mock failure, design the next task to separate them. If a learner misses a conditional exception, is the source grammar unknown, or did time pressure cause skipping? Give an untimed explanation task. If they fail, teach grammar. If they succeed, add a timed fresh paragraph.

If a learner researches too much, is terminology genuinely unfamiliar or is the stopping criterion weak? Give familiar terminology with ambiguous stylistic alternatives. If searching still sprawls, reassurance may be the mechanism.

If final-task quality falls, is it position or difficulty? Use balanced tasks in a mini-simulation. Rotate their order if your training design permits. A discriminating question reduces guesswork.

This is one of the most powerful uses of a mock: not to answer everything, but to tell you which question to ask next.

The difference between readiness evidence and learning evidence

Readiness evidence comes from conditions close enough to the target performance that the observation transfers meaningfully: independent work, representative time, appropriate resources, unseen material and relevant task structure. Learning evidence can come from much more supported conditions.

A learner who corrects an error after a teacher hint has produced excellent learning evidence: the concept may be within reach. It is not independent readiness evidence for that decision. Both matter.

Keep these evidence types side by side. The training pathway often moves from supported learning evidence to independent component evidence to integrated mock evidence.

Confusing them can create false pessimism as well as false optimism. Guided work should not be dismissed because it is not independent; it is how independence is built.

The difference between stable and brittle success

Stable success survives reasonable variation. Brittle success depends on one familiar topic, one exact passage type, one visible checklist or one teacher prompt. A mock portfolio should gradually test whether success survives changes that belong inside the intended task family.

Do not attack stability by changing everything at once. Remove one support or vary one mechanism. If performance holds, test another dimension later.

Brittleness is not failure; it is a stage. A newly learned routine often begins context-bound. Training broadens the conditions under which it works.

Readiness becomes more credible when the learner’s process remains recognisable across unseen material and ordinary variation.

The difference between a hard mock and a useful mock

A hard mock creates difficulty. A useful mock creates information. They can overlap, but they are not identical. An excessively specialist passage can be hard while telling a general translator little about the intended assessment. A moderate passage can be highly useful if it reveals a recurring reference failure under realistic timing.

When selecting material, ask whether the difficulty comes from decisions the assessment legitimately expects. If yes, keep it. If difficulty comes from irrelevant specialist knowledge or artificial trick design, reconsider.

Students often request “the hardest possible mock” because surviving it feels reassuring. Explain that fidelity and diagnostic value matter more than extremity.

Stress practice can exist as a separate labelled exercise. Do not confuse it with the best readiness measure.

The difference between more practice and better practice

More practice increases exposure. Better practice changes the decision process. The two can reinforce each other, but volume without diagnosis can stabilise inefficient habits.

After each mock, ask what the next repetition is supposed to improve. If the answer is simply “get used to it,” define what “it” means: session length, platform, passage choice, research pressure, task switching or revision durability.

Once that component is familiar, another identical mock may add little. Shift to a new legitimate variation or targeted repair.

High-quality preparation is selective repetition with feedback and transfer.

The difference between a score plateau and a learning plateau

A score can stay similar while the underlying process improves. Research becomes shorter, revision becomes more systematic and errors become less consequential, but harder material keeps the headline number flat. Conversely, a score can rise while the same blind spot remains.

Inspect dimensions beneath the score before declaring a plateau. If process and error quality are improving, continue the current direction. If nothing changes across repeated comparable attempts, the training stimulus may need revision.

Use external scoring criteria where appropriate, but preserve the diagnostic layer underneath. The learner needs both outcome and mechanism.

A plateau is a question: what is no longer changing, and why?

Closing casebook — A mock with excellent timing and weak fidelity

A learner completes every task early and performs a full revision. The trace is excellent. Later the teacher notices that the local mock allowed unrestricted internet tools while the intended assessment restricts them. The correct conclusion is not that the attempt was useless. It shows what the learner can do under that resource condition. It does not yet show representative independent performance.

The next action is a resource-matched timed component before another full simulation. If performance remains stable, the earlier process strengths become more transferable. If research time rises sharply, the resource dependence has been located.

This case demonstrates why fidelity is part of interpretation, not merely mock setup.

Closing casebook — A mock with weak timing and excellent self-correction

A learner runs out of time with half a paragraph incomplete. Immediately afterward, without teacher help, they identify the overlong research episode, finish the paragraph accurately and explain the source structure correctly. The timed result is incomplete, but the learning evidence is strong.

The repair should target execution, not reteach the entire language concept. Research stopping and drafting checkpoints are likely higher-value than more explanation of the source sentence.

The next evidence source is a timed fresh passage, not necessarily a full mock. If the process fits there, integration can be retested later.

Closing casebook — A mock with one severe error and otherwise stable performance

A learner completes a strong session but reverses one critical date condition. Do not average the error away because everything else is good, and do not declare the whole process broken because one error is serious.

Investigate whether date boundaries have failed before. If yes, it is a recurring high-consequence pattern and deserves immediate repair. If no, run a targeted boundary check and monitor the next representative attempt.

Severity and recurrence are separate dimensions. Training decisions need both.

Closing casebook — A mock with many small language issues

The source meaning is mostly preserved, but later target prose becomes awkward and punctuation deteriorates. The learner’s final revision is consumed by checking transfer, leaving no target-only pass.

One repair is to improve first-pass transfer reliability so source checking becomes cheaper. Another is to train target-language patterns outside the mock. A third is to protect the two-pass revision structure. Which comes first depends on the trace.

Do not simply tell the learner to “write more naturally.” Give the target-language problem a practice mechanism.

Closing casebook — A mock that is strong only with a visible checklist

The learner’s process is controlled when a detailed checklist sits beside the screen. The intended assessment would not permit that aid. This is a support-dependence finding, not a failure of the underlying knowledge.

Fade the checklist: full list, abbreviated headings, one mnemonic, then none. Test each stage with fresh tasks. If behaviour survives, independence is increasing.

Do not remove the scaffold abruptly if it causes the whole process to collapse. Fading is training, not a test of toughness.

Closing casebook — A mock with a strong score and poor self-calibration

The learner receives strong external feedback but believes several correct decisions were wrong and spends large amounts of time doubting them. The product is strong; the process is expensive.

Use confidence-calibration review. Ask what evidence supports each correct decision. Build fresh alternatives where more than one target is defensible. The aim is to reduce unnecessary uncertainty without encouraging carelessness.

A strong score can therefore still produce a valuable repair target.

Closing casebook — A mock with a low score but one clear cause

A learner’s result is poor because one source-language construction appears repeatedly and is misunderstood. The rest of the process is orderly. This is good diagnostic news: the problem is narrow enough to teach.

Stop full simulations. Teach the construction, contrast it with near forms, retrieve it later, translate fresh examples and retest in a paragraph. Then return to representative integration.

A low outcome can lead to a short repair path when the mechanism is clear.

Closing casebook — A mock with no score at all

Many local simulations will not have a validated score. They can still generate rich evidence: completion, process trace, bilingual review, recurring error families, revision yield, resource discipline and independence.

Do not invent a percentage merely to make the mock feel official. Describe the observations directly. If a qualified external reviewer is available, use their feedback without converting it into a credential prediction unless the provider’s system supports that interpretation.

Measurement does not require false precision.

Closing casebook — The final mock is not the final lesson

The final representative rehearsal can be strong, weak or mixed. Whatever it returns, preparation still has one more job: choose the smallest sensible final action. That may be preserving the system, refreshing a terminology family, checking official logistics or repairing one narrow error.

Do not turn the last mock into a verdict that changes the learner’s identity. It is one fresh integrated observation.

The broader translation system continues beyond the simulation: read accurately, decide with evidence, write naturally, verify carefully and act within the actual constraints of the task.

Technical note — Why one mock cannot establish a stable rate

A single mock samples one set of texts under one set of conditions. Translation time depends on language direction, terminology, source structure, target genre, research demand and the learner’s current knowledge. Treating one completion time as a permanent personal speed ignores that variation.

Use repeated reasonably comparable tasks to establish a range. Then look at what moves the learner towards the slow or fast end. A dense reference chain may add time. Familiar terminology may reduce it. A new platform may create operational overhead.

Ranges support planning without pretending every passage is equivalent. They also make unusual results visible: a mock far outside the recent range deserves investigation.

The timed-translation owner discusses component speed more deeply. In mock analysis, the unit of interest is the whole session’s ability to fit the required architecture while preserving quality.

Technical note — Why a repeated error deserves a fresh context

If a learner corrects “up to three” after feedback and then gets the same sentence right, the repair may be memory of the answer. Change the surface context: up to three books, up to three applications, up to three materials packs. Then vary the syntax while preserving the boundary.

Fresh context forces the learner to retrieve the relationship rather than the wording. This is the basis of transfer testing.

When the learner succeeds in short fresh contexts, embed the relationship among distractors in a paragraph. Later, hide it in a mock. Each step removes cues.

The progression protects the mock from becoming the place where basic transfer is first attempted.

Technical note — Why the final revision pass should be trained separately

By the end of a long simulation, the learner may be tempted to reread passively. Active checking requires a search target. Source-to-target review searches for transfer failures. Target-only review searches for language and clarity. Mechanical review searches for names, numbers, dates and temporary marks.

Train these passes on completed targets when the learner is fresh so the method is known. Then test whether the same method survives the full mock. You are separating skill acquisition from endurance.

If the method collapses late, shorten it to its highest-yield core and train durability. Do not invent the checking routine for the first time in the final minutes of a mock.

A revision reserve is useful only if the learner knows what to do with it.

Technical note — Why task switching should be observable

Switching is easy to ignore because it takes little clock time. Its cost can appear later as terminology carryover, wrong audience assumptions or loss of source context. Mark task transitions in the trace even if they take only seconds.

Review the first paragraph after each transition. If the pattern is clean, switching is probably not a priority. If errors cluster there, a reset routine has a clear target.

Do not overinterpret one transition. A hard opening sentence can mimic a switching problem. Compare across tasks and simulations.

Observability is valuable because it makes small invisible process boundaries available for teaching.

Technical note — Why mocks should contain ordinary text too

If every sentence is designed as a trap, the learner knows to scrutinise everything and the mock stops resembling normal translation. Realistic texts contain ordinary stretches, repeated information, straightforward syntax and a smaller number of high-risk decisions.

Ordinary text tests attention allocation. Can the learner move efficiently through low-risk units and slow down where the source demands it? A uniformly difficult mock cannot reveal that selectivity.

It also tests target-language rhythm. Translation is not a sequence of isolated puzzles; the final document must cohere.

Design locally created mocks as texts first and diagnostic instruments second. The challenge should arise naturally from meaning relationships.

Technical note — Why post-mock repair should sometimes be untimed

When a concept is misunderstood, time pressure can hide the shape of the misunderstanding. Remove the clock and ask the learner to explain the source. Give them enough time to compare alternatives and consult appropriate evidence.

Once the representation is correct, reintroduce timing. This separates “cannot yet do” from “can do but not quickly enough.” The training paths differ.

Untimed repair is not easier practice in a dismissive sense. It is the laboratory where the mechanism can be inspected without the confound of speed.

The mock finds the weakness; untimed work can make it understandable; timed transfer makes it executable.

Technical note — Why the next mock should not target only the repair

After repairing a known weakness, the learner should face it again, but a full mock should not become a giant disguised worksheet on that one feature. If every passage contains the repaired structure, the learner is heavily cued.

Include the feature naturally among unrelated decisions. The learner must notice it without expectation while also managing the rest of the system.

This is the difference between a transfer test and a representative integration test. The former concentrates the feature; the latter embeds it.

Both are necessary at different stages.

Technical note — Why mock evidence belongs to the learner

The learner should understand what the records mean. A dashboard hidden from them can help a teacher plan, but self-regulation grows when the learner can read the trace, identify a bottleneck and explain the next task.

Use accessible language alongside technical categories. “Reference error” can be explained as “the target attached ‘they’ to the wrong group.” “Resource inefficiency” can be explained as “three searches did not change the answer.”

As the learner gains expertise, they can maintain more of the ledger themselves. The training system becomes less teacher-dependent.

The end state is not perfect self-marking. It is informed participation in one’s own preparation.