Practical TypeScript
GitHub

Get back to TypeScript.

A practical refresher for developers returning to TypeScript.

Start the refresherBrowse topics

Choose a topic

Read the rule, write the code, then open the explained answer.

Language and types

Inference, narrowing and types that preserve useful relationships.

JavaScript and collections

Equality, copying, grouping and deduplication.

Async and failures

Promises, concurrency limits, timeouts and retries.

Data and algorithms

Idempotency, database writes and algorithm patterns.

Tools and code review

Compiler errors, modules, debugging and tests.

Write the code

Work through independent tasks, then try the timed mock.

Practice

Three connected exercises: validate an update, keep the latest version, then save with bounded concurrency. Start with the contract and write your solution before opening the spoiler.

Practice in this domain

Prefer a guided route?

Return to TS

Language → runtime → types → tools → async → practice → mock

Start this route: Return to TS

Backend interview practice

Data → TS → async → ingestion → review → practice → mock

Start this route: Backend interview practice

Optional self-check

An optional check of 12 specific rules, about 5–10 minutes. Choose “I don’t know” when unsure. Each answer has an explanation and references; the result is not a coding skill assessment. Answers are not uploaded or saved when you leave this page.

Try 12 questions
1. Presence
const retries = 0;
const effective = retries || 3;

What is effective?

2. External input
const value: unknown = null;

Is typeof value === "object" sufficient to access fields?

3. Inference
const job = { status: "queued" };

What is the type of job.status without contextual typing?

4. Optional properties
type Patch = { name?: string };

With exactOptionalPropertyTypes, is { name: undefined } accepted?

5. Readonly
type State = Readonly<{ tags: string[] }>;

Does State prohibit state.tags.push("new")?

6. Generic relationships
function first<T>(xs: readonly T[]): T | undefined

What does T preserve?

7. Object identity
new Set([{ id: "A" }, { id: "A" }]).size

How many elements remain?

8. Async order
await Promise.all([slow(), fast()])

In what order are results returned?

9. Concurrency
await Promise.all(items.map(load))

Does this limit concurrent loads to four?

10. Unknown errors
try { run(); } catch (error) { /* … */ }

How can strict code safely obtain a message?

11. Event delivery
{ eventId: "E1", entityId: "A" }

Which key distinguishes replay from another update to the same entity?

12. Running TS
node example.ts

Does successful execution guarantee no type errors?

Coverage and limits

Practical TypeScript and backend coding. SQL, algorithms and durable delivery are introductions; specialist topics need separate preparation.

Practised with implementationsSources
Types, inference, narrowing and practical genericsReturning to TypeScript: the language · Practical TypeScript contracts · Type design beyond basic generics
Collections, concurrency, ingestion and failure reportsCollections and data processing · Async work and the event loop · Implement a concurrency limiter · Fetching data: pages, timeouts and retries · Workshop: write the code yourself

Introduced, needs deeper practice

SQL, durable delivery, BFS/DFS/heaps and Node runtime. Events, idempotency and database writes · Algorithm patterns in TypeScript · Compiler settings, modules and running TS

Separate preparation needed

React/DOM, framework APIs, authentication/security, system design, advanced DP and distributed transactions

TypeScript Handbook · MDN JavaScript · Node.js