Placement without labels
Self-select a level or use a future short placement workout. You can combine blocks when prerequisites are met and revisit a focused refresher without restarting.
HomeBuild judgment
Build judgment
that lasts.
CodeStamina is planning a catalog of deliberate practice for developers—from first programs to system-wide decisions.
The five levels are starting guidance, not job titles or a universal rank. Choose by the outcome you want and the experience you have in that subject.
THE PLANNED CATALOG
Five levels. One clear route at a time.
The topic inventory below is planned curriculum, not a claim that every workout is available. Today you can try one complete guided TypeScript exercise without signing in.
01
Foundations
Create a small program from a clear brief, check its behaviour and explain how it works.
Getting started4 topics
Programs, inputs and outputs
Understand how instructions turn inputs into observable results.
Running code and reading feedback
Run a small program and distinguish output from an error message.
Values, variables and basic types
Work with text, numbers and booleans using meaningful names.
Expressions and comparisons
Calculate values and express conditions clearly.
Controlling behaviour4 topics
Conditions and branching
Choose behaviour with if/else and simple decision rules.
Loops and repetition
Repeat work with explicit stopping conditions.
Functions, parameters and returns
Split a task into small reusable operations.
Scope and changing state
Track where a value is available and when it changes.
Working with data4 topics
Strings and text operations
Inspect, format and transform simple text.
Arrays and iteration
Store ordered values and process each item.
Objects and records
Represent related information with named fields.
Missing, empty and invalid values
Recognize that absent data and empty data can mean different things.
Building confidence5 topics
Reading and tracing code
Predict results by following execution step by step.
Finding and fixing basic bugs
Use errors and small examples to locate a mistake.
First tests and examples
Check normal cases and a few important boundaries.
Breaking down a problem
Turn a short requirement into manageable steps.
Naming, formatting and explanation
Make a small solution easy for another person to understand.
Integration1 topic
Small-program practice
Combine the level's skills in a converter, validator or summary tool.
02
Practical Developer
Turn a small feature brief into understandable, typed and tested behaviour.
Expressive TypeScript5 topics
Type annotations and inference
Describe values and let inference remove unnecessary repetition.
Object types and interfaces
Define clear shapes for inputs, outputs and shared data.
Unions and narrowing
Represent alternatives and handle each possibility safely.
Optional values and null handling
Make absence explicit and choose sensible fallback behaviour.
Reusable generic functions
Preserve useful type information in simple reusable helpers.
Everyday data work5 topics
Filtering, mapping and reducing
Transform collections without obscuring the intent.
Grouping, sorting and lookup
Organize records and retrieve the right information.
Immutability and references
Understand shared objects and avoid accidental mutation.
Parsing and validation
Turn external text or JSON into checked application data.
Dates, units and numeric boundaries
Handle common representation and calculation mistakes.
Feature construction5 topics
Modules and dependencies
Divide a small feature into understandable responsibilities.
Promises and async/await
Follow asynchronous work and handle its result.
HTTP and API basics
Understand requests, responses, status codes and response validation.
Errors and useful messages
Distinguish expected invalid input from unexpected failure.
Resource lifecycle basics
Acquire and release resources without leaving work unfinished.
Verification and maintenance5 topics
Unit tests and assertions
Describe expected behaviour through focused checks.
Boundary tests and regressions
Preserve a bug fix with a test that catches the original mistake.
Debugging from evidence
Use reproduction steps and observations to test a hypothesis.
Small refactors and code review
Improve clarity while checking that behaviour stays the same.
Git and change hygiene
Understand diffs, make focused changes and explain their purpose.
Integration1 topic
Small-feature practice
Build a validated data-processing feature with tests and a short handoff.
03
Reliable Developer
Diagnose realistic defects and preserve correct behaviour under boundaries, asynchronous changes and partial failure.
Data correctness4 topics
Boundary transformations
Preserve distinctions between missing, empty, zero and false values.
Stable grouping and indexing
Define ordering, identity and duplicate handling explicitly.
Conflicting and malformed records
Separate usable data from conflicting or invalid inputs.
Contracts and invariants
State the conditions a component must always preserve.
Failure handling4 topics
Error classification
Separate retryable failures, permanent failures and cancellation.
Retry policies and backoff
Make bounded retry decisions without repeating unsafe work.
Timeouts and deadlines
Distinguish waiting limits from completion and failure semantics.
Cancellation and cleanup
Stop obsolete work and release resources consistently.
Asynchronous correctness4 topics
Ordering and stale results
Prevent older work from overwriting newer state.
Concurrency limits
Bound parallel work and account for success and failure.
Idempotency and duplicate events
Process repeated requests without unintended repeated effects.
State transitions
Make valid transitions and terminal states explicit.
Stronger verification4 topics
Protective test design
Catch realistic defects without rejecting valid alternative solutions.
Deterministic asynchronous tests
Control time and completion order to reproduce difficult cases.
Test doubles and dependency boundaries
Isolate a behaviour without testing an unrealistic imitation.
Property-based thinking
Check general rules across varied inputs, beyond hand-picked examples.
Safe maintenance3 topics
Behaviour-preserving refactoring
Simplify implementation while protecting observable contracts.
Compatibility and change impact
Recognize which callers depend on existing behaviour.
Logs and failure diagnosis
Choose observations that explain a failure without exposing sensitive data.
Integration1 topic
Reliability practice
Combine validation, asynchronous control and tests in an unfamiliar task.
04
Advanced Engineering
Improve a service or application using explicit design, performance and operational tradeoffs.
Service design4 topics
Module boundaries and dependency direction
Keep responsibilities clear and changes contained.
API contracts and evolution
Change an interface while supporting existing consumers.
Domain modelling
Represent business rules without scattering them through unrelated code.
Configuration and feature controls
Handle defaults, overrides and invalid combinations predictably.
Data and persistence4 topics
Relational modelling and constraints
Put relationships and integrity rules into a coherent data model.
Transactions and concurrent updates
Preserve correctness when several operations modify shared data.
Schema migrations and backfills
Change stored data while considering compatibility and recovery.
Query performance and indexes
Explain slow access patterns and choose targeted improvements.
Performance and resilience5 topics
Complexity and profiling
Use workload evidence to locate costly work.
Memory and resource pressure
Recognize leaks, unbounded collections and expensive allocation.
Caching and invalidation
Balance reuse, freshness and failure behaviour.
Queues and backpressure
Prevent incoming work from overwhelming processing capacity.
Partial failure and graceful degradation
Preserve useful behaviour when a dependency is unavailable.
Security and operations4 topics
Authentication and authorization boundaries
Distinguish identity from permission and enforce access consistently.
Untrusted input, secrets and sensitive data
Identify unsafe trust assumptions and reduce unnecessary exposure.
Observability and service health
Connect logs, metrics and traces to questions about real behaviour.
Incident diagnosis and recovery
Form hypotheses, reduce impact and verify recovery.
Verification and change2 topics
Integration and contract tests
Check component interactions and interface expectations.
Release safety and rollback
Plan incremental change and a workable recovery path.
Integration1 topic
Production-change practice
Improve an existing service and justify correctness and operational checks.
05
Systems and Technical Judgment
Compare system designs, investigate ambiguous failures and plan safe evolution under real constraints.
Distributed behaviour5 topics
Consistency and availability tradeoffs
Explain which guarantees a workload needs during failure.
Delivery and processing guarantees
Reason about loss, duplication and repeated effects across boundaries.
Event ordering and reconciliation
Handle late, missing and out-of-order information.
Coordination, leases and ownership
Reason about competing workers and changing ownership.
Distributed workflows and compensation
Recover from partially completed multi-step operations.
Scaling and resilience5 topics
Partitioning and hot spots
Distribute work while accounting for uneven demand.
Capacity and cost reasoning
Relate workload assumptions to limits, headroom and expense.
Cascading failures and overload
Trace how local pressure can spread across a system.
Resilience experiments
Test failure assumptions with bounded, purposeful scenarios.
Disaster recovery and restoration
Define recovery needs and verify that restoration is usable.
System evolution5 topics
Architectural tradeoff analysis
Compare options against explicit constraints and consequences.
Legacy modernization
Replace or improve old components in manageable steps.
Data and service migration
Plan coexistence, reconciliation and cutover across systems.
Multi-tenant isolation
Balance shared resources with tenant boundaries and fairness.
Threat modelling
Identify valuable assets, trust boundaries and plausible abuse paths.
Technical judgment4 topics
Ambiguous requirements
Turn uncertainty into questions, assumptions and testable decisions.
Design review and decision records
Make reasoning understandable enough to challenge and revisit.
Build-versus-buy and dependency risk
Compare ownership costs, constraints and exit options.
Incident learning and systemic fixes
Convert a failure into prioritized improvements beyond the immediate bug.
Integration1 topic
Systems case study
Defend a design, respond to a failure scenario and revise the proposal.
FIRST RELEASE
Four weeks of TypeScript Reliability.
This focused block sits within Level 3 and assumes Level 2 readiness. Three short workouts a week practise boundaries, async behaviour, failure handling and verification.
Completing these 12 sessions does not mean completing all of Level 3. Follow-on blocks cover the rest of the planned level.
- 01
Week 1
Boundaries and baseline
Repair a transformation and identify missing and empty values.
- 02
Week 1
Grouping with a clear contract
Build a grouping utility with explicit identity and ordering rules.
- 03
Week 1
Tests that protect behaviour
Catch a realistic boundary defect while accepting correct alternatives.
- 04
Week 2
Understanding failures
Distinguish retryable, permanent and cancelled outcomes.
- 05
Week 2
Latest result wins
Prevent an older asynchronous result from replacing a newer one.
- 06
Week 2
Bounded retries
Apply a capped retry policy with predictable time inputs.
- 07
Week 3
Cancellation that holds
Preserve cancellation and cleanup across asynchronous steps.
- 08
Week 3
Refactor with confidence
Simplify branching while preserving externally visible behaviour.
- 09
Week 3
Process an event once
Handle duplicate event identities without duplicate effects.
- 10
Week 4
Put reliability together
Combine validation, failure handling and a small feature.
- 11
Week 4
Fresh-context challenge
Apply the skills to an unfamiliar reserved task.
- 12
Week 4
Reassessment and next block
Review fresh evidence and select a continuation or refresher.
A FLEXIBLE ROUTE
Start where the subject starts for you.
Progress that survives editions
Meaningful curriculum changes will become a new edition. Learners should be able to finish their chosen edition or move deliberately, while completed work stays visible.
Practice, then revisit
Short workouts introduce, predict, solve, verify and explain. Later reviews use a different context so activity and independent capability are not confused.
More tracks can grow from the same approach.
These are expansion directions, not launch commitments. Each needs a complete outcome and usable learning material before it is offered.
Comeback
Rebuild fluency with a baseline, supported practice and gradually reduced scaffolding.
Maintenance
Rotate practised skills, unfamiliar variants and delayed checks.
Testing and Debugging
Practise reproduction, test design, asynchronous failures and diagnostic evidence.
Frontend Engineering
Cover semantic HTML, CSS, accessibility, browser behaviour, state and UI testing.
Backend and Data
Cover HTTP, validation, persistence, transactions, queues, caching and reliability.
Algorithms and Data Structures
Practise collections, search, sorting, recursion, trees, graphs and complexity.
Secure Development
Work with trust boundaries, access control, data handling and threat modelling.
Language and Stack Bridges
Transfer familiar concepts into a new language or ecosystem.
AI-Assisted Code Review
Explain generated changes, challenge assumptions, find defects and verify results.
FUTURE DIRECTION
Personal routes first. Shared programs later.
CodeStamina may let people arrange available topics into a private route, then share clear editions with attribution and transparent coverage.
Original community material, review labels and curation would come later. This is a direction we want to learn about, not a feature available today.