Company A — Junior Strong / Middle Python Developer — prep map

Checklist format: tick what you can explain and defend under questioning, not what you have used. Bold is the primary note; the rest add depth.

Priority: 🔴 core (in the ad, will be probed) · 🟡 important (in the ad, lighter) · 🟢 breadth (implied)

The ad, decoded

The product this ad describes: a real-time voice/transcription service — audio in over a WebSocket, a speech pipeline, Claude in the middle, results back over the same connection, everything stored in Postgres. Prepare the whole system end to end (section “The design question”, below), not just the parts.

🔴 Python fundamentals

• Mutable vs immutable, references, copies — the def f(x=[]) family↳Mutable vs immutable·Argument passing·Shallow vs deep copy·Mutable default arguments
• Classes, self, class vs instance attributes, @classmethod / @staticmethod↳Classes in Python·staticmethod vs classmethod·Class var vs instance var·Magic methods
• __eq__ / __hash__, is vs ==, dict keys↳__eq__ vs __hash__·is vs ==·Hashable objects as keys
• Generators and iterators; yield; exhaustion↳Iterators and generators·Generator exhaustion·itertools
• Decorators, context managers, contextlib↳Decorators and context managers·contextlib·functools.wraps·Decorator with arguments
• Exceptions — try/except/else/finally, custom hierarchies, chaining↳try / except·Exception swallowing in finally
• Imports, modules, packages, circular imports↳Imports and the module system·Circular imports
• dataclasses vs Pydantic; *args / **kwargs; scope↳dataclasses·dataclass vs attrs vs Pydantic·*args and **kwargs·Variable scope
• The GIL and memory model — enough to answer “threads or async”↳The GIL·Memory model and GC
• Tricky questions sweep — read the folder once, they ask these verbatim↳Tricky questions·Late-binding closures·Truthiness·Dict mutation during iteration

🔴 typing

• Optional, Union, Callable, list[str] vs List — the basics, fluently↳Optional, Union, Callable
• TypeVar, generics, PEP 695 class Box[T]↳TypeVar and generics
• Protocol vs ABC — structural typing, and when a base class is wrong↳Protocol and structural typing·Protocols and interfaces
• TypedDict, Literal, Final, Annotated, TypeGuard↳TypedDict, Literal, Final·Annotated and TypeGuard
• mypy / pyright in CI; what “strict” costs↳mypy and pyright strictness·Type-checking strategy·Type-driven development

🔴 async / await

• Coroutines, the event loop, await, tasks — what actually runs when↳Async Python and coroutines·Event loop internals·async def returns a coroutine
• Blocking the loop — the bug behind most “async is slow” stories↳Blocking in async·run_in_executor / to_thread·asyncio vs threads
• TaskGroup, gather, cancellation, timeouts↳TaskGroup and structured concurrency·Cancellation, timeouts, errors
• asyncio.Queue, backpressure, producer/consumer — the audio pipeline’s spine↳asyncio.Queue vs threading.Queue·Synchronization primitives·CPU vs I/O tasks
• Async in FastAPI — def vs async def routes, the threadpool↳FastAPI async and performance·run_in_threadpool·FastAPI async

🔴 WebSockets and real-time communication

• The protocol — handshake, frames (text vs binary), close codes, ping/pong↳WebSocket protocol·WebSocket vs SSE vs long-poll·Server-Sent Events
• Python implementation — websockets, FastAPI endpoint, Django Channels↳Python implementation·Async Django and Channels
• Connection management — heartbeats, timeouts, reconnection, backpressure, graceful shutdown↳Connection management
• Auth and security on a socket — token at the handshake, origin checks↳Authentication·Security
• Scaling — sticky sessions, broker fan-out, one process per connection↳Scaling·Socket.IO·nginx WebSocket proxying
• Audio over the socket — control JSON + binary frames, reader/queue/consumer, barge-in↳Streaming audio over WebSockets·WebRTC and WebTransport·TCP vs UDP

🔴 Audio processing and streaming

• PCM: sample rate, bit depth, channels; the byte arithmetic — 20 ms at 16 kHz mono int16 = 640 bytes↳Audio fundamentals for backends
• The three bugs — rate mismatch, layout mismatch, odd-length chunks (remainder buffer)↳Audio fundamentals for backends(§ The three bugs)
• Codecs vs containers — WAV, Opus/WebM, μ-law telephony, MP3; ffmpeg over pipes; resampling↳Audio fundamentals for backends(§ Containers and codecs, § Converting)
• Capture — browser MediaRecorder vs AudioWorklet, telephony media streams, sounddevice↳Streaming audio over WebSockets(§ Where the browser makes it hard)
• STT and TTS — streaming vs batch, interim vs final, WER and why it misleads, time to first byte↳Speech: STT and TTS·Voice platforms
• VAD, endpointing, turn detection, barge-in; the latency budget↳Realtime voice agents

Have the numbers ready: 16 kHz mono int16 = 32 KB/s; a 20 ms frame is 320 samples / 640 bytes; telephony is 8 kHz μ-law at 8 KB/s; base64 adds a third. Say them without looking and the “audio experience” line is covered.

🔴 Claude API — prompt design, structured outputs, tool calling

• The Messages API shape — system vs messages, content blocks, stop_reason, stateless history↳The Claude Messages API in practice·The chat API
• The tool loop — tool_use → run → tool_result by tool_use_id; all parallel results in one message; is_error↳The Claude Messages API in practice(§ Tool use)Function calling and structured output·The agent loop
• Structured outputs — messages.parse / output_config.format; shape is guaranteed, truth is not; Pydantic after↳Function calling and structured output·LLM JSON validation·Pydantic in practice
• Prompt design — stable-first ordering, tagged inputs, examples, no prefill, thinking and effort↳Prompt engineering·Prompt optimization·Context windows
• Streaming, caching, retries, batches — the production habits↳The Claude Messages API in practice(§ Streaming, § Prompt caching, § Errors)Provider abstraction and resilience·LLM gateway and caching
• Injection and output validation — the user’s audio transcript is untrusted input↳Prompt injection·Guardrails and output validation·Hallucinations and tools
• Evaluating an LLM feature — a small eval set beats opinions↳Building eval sets·Why LLM eval is hard

🔴 Web frameworks — FastAPI first

• FastAPI end to end — routing, Pydantic models, dependencies, middleware, exceptions↳FastAPI overview·Dependencies and injection·Pydantic models·Middleware·Exception handling
• Project structure, background work, external clients↳Project structure·Background tasks vs Celery·External API client
• Testing FastAPI, including WebSocket endpoints↳FastAPI testing·pytest-asyncio·Mocking external APIs
• Auth, OpenAPI, deployment↳Security and authentication·OpenAPI and docs·Deployment·WSGI vs ASGI
• Flask and Django — enough to compare; the ORM and Channels if Django comes up↳Flask·Django vs DRF·Django ORM guide·select_related vs prefetch_related
• REST hygiene — status codes, idempotency, versioning, pagination↳REST principles·Idempotency·Status codes·Versioning and pagination

🔴 Relational databases, SQLAlchemy, SQL, data modeling

• SQL fundamentals, joins, transactions, isolation↳SQL fundamentals·Transactions·Isolation levels·Window functions and CTEs
• Efficient queries — indexes, EXPLAIN ANALYZE, why the index is not used, N+1↳Indexes·EXPLAIN ANALYZE·Why your index is not used·N+1·Index types
• Data modeling — keys, relations, normalisation, when to denormalise↳Relations and keys·SQL vs NoSQL·Sharding and partitioning
• SQLAlchemy 2.0 — Core vs ORM, session lifecycle, loading strategies, async↳SQLAlchemy·Core vs ORM·Session lifecycle·Loading strategies and N+1·Async SQLAlchemy·Common pitfalls
• Migrations and pooling — Alembic, zero-downtime changes, connection pools↳Alembic·Zero-downtime migrations·Connection pooling
• PostgreSQL vs MySQL — the differences that matter in an answer↳MySQL·Isolation anomalies across DBs·pgvector in production

🟡 Code quality, documentation, data profiling

• Formatters, linters, pre-commit, review↳Formatters·Linters·Pre-commit and review
• Google-style docstrings — what a docstring must say, and docstrings as tool schemas↳Docstrings and documentation
• Refactoring, tech debt, complexity↳Refactoring·Tech debt and complexity·SOLID
• Data profiling — nulls, cardinality, distributions, duplicates, freshness; then checks↳Data profiling and validation
• Testing — pytest fixtures, parametrize, mocks, property tests↳pytest concepts·Fixtures·Mock vs MagicMock vs patch·Test pyramid

🟡 Data processing pipelines

• pandas, and when it breaks↳pandas fundamentals·groupby, merge, reshape·When pandas breaks·Polars
• Pipeline design — idempotent steps, incremental loads, quality checks in the run↳ETL orchestration and dbt·Parquet
• Queues for the slow parts — Celery, retries, idempotency, dead letters↳What is Celery·Retries·Idempotency·Broker comparison

🟡 Docker

• Image vs container, layers, multi-stage builds, compose, volumes, networks↳Docker·Image vs container·Image layers·Multi-stage builds·Compose·Volumes
• A Python service in a container — Uvicorn workers, env config, health checks↳FastAPI deployment·CI/CD basics·GitHub Actions

The design question to rehearse

“Design a service that transcribes a live call and answers questions about it.” Walk it in this order, and link each step to a note you have read:

1. Client captures audio → binary frames over a WebSocket with a start message declaring rate and encoding — Streaming audio over WebSockets.
2. Server: reader task → bounded asyncio.Queue → STT stream task; partial/final transcripts back as JSON — asyncio.Queue, Connection management.
3. Audio hygiene: 16 kHz mono int16, remainder buffer, VAD gating — Audio fundamentals.
4. Finals go to Claude with a stable system prompt, structured output for the answer, tool calls for lookups — Claude Messages API.
5. Persist transcripts and answers in Postgres via SQLAlchemy async sessions; index by call and time — Async SQLAlchemy, Indexes.
6. Ship it: Docker image, one process per connection, sticky sessions, metrics — Scaling, Deployment.

Then name the failure modes unprompted: slow work in the reader, unbounded buffers, interim transcripts stored as final, a date in the system prompt killing the cache, N+1 when listing calls.

Behavioural — the Company A values as stories

• The story structure and the six signals — every answer as context → options → decision → trade-off → result↳The six signals·Joining an existing project·Working independently
• Questions to ask them, and the red flags↳Closing questions and red flags

English: the whole call is in English. Rehearse the design walk-through above aloud, in English, twice — the ad’s English-level line is scored on exactly that.