Practical learning paths by Shreyam Adhikari on Cloudflare Workers, React systems, and developer tool design.
PTLearn is a practical software course product by Shreyam Adhikari with code examples, diagrams, quizzes, flashcards, labs, and local-first progress.
-
Build testable APIs with dependency injection, async database boundaries, auth, background jobs, and production error handling.
Backend craft - Intermediate
- Routing and Validation Basics — Design a reviewable FastAPI contract with typed create/read schemas, explicit status semantics, validation evidence, route tests, and an OpenAPI drift check.
- Advanced Dependency Injection — Design FastAPI dependency boundaries for request-scoped sessions, authenticated users, framework-free services, and test overrides that cannot leak between cases.
- Repository and Unit of Work — Own a subscription billing write flow with product-language repositories, one explicit unit-of-work transaction, rollback proof, and routes that never reach through ORM details.
- Testing, Packaging, and Operations — Package a FastAPI service so reviewers can prove route contracts, dependency overrides, startup commands, and liveness/readiness behavior before traffic reaches it.
- Observability and Error Contracts — Design a FastAPI failure surface with stable ProblemDetails-style responses, request IDs, structured logs, bounded metrics, and a diagnostic playbook operators can actually follow.
- Deploys, Workers, and Runbooks — Finish the FastAPI service with graceful worker shutdown, traffic-safe readiness gates, deploy smoke checks, rollback thresholds, and a two-minute handoff runbook.
-
Design React interfaces with typed state, resilient effects, accessible controls, and performance-aware layout.
Frontend systems - Intermediate
- TypeScript Component Foundations — Use props, unions, and small component contracts to make UI states explicit before screens grow complex.
- State Machines for UI Flow — Replace boolean soup with compact discriminated states that explain what the screen can do next.
- Performance-Friendly Layout — Use stable dimensions, lazy boundaries, and predictable render paths to avoid layout shifts.
- Server State, Forms, and Tests — Build a production form flow with typed API parsing, TanStack Query ownership, optimistic cache updates, rollback, accessible errors, and behavior-focused tests.
- Accessibility and Error Recovery — Design UI flows that announce state changes, preserve focus, recover from failure, and stay usable on mobile.
- Frontend Observability and Release Readiness — Instrument user-visible flows with safe events, performance marks, screenshots, and release checks before shipping.
-
Build small Go services with clear context propagation, concurrency control, observability, and deployment discipline.
Reliable services - Intermediate
- HTTP Service Basics — Build a small JSON API with standard handlers, structured errors, timeouts, and a simple project layout.
- Context and Cancellation — Make timeouts and shutdown signals flow through every expensive operation.
- Interfaces at Boundaries — Use interfaces where they describe ownership seams, not everywhere by habit.
- Storage, Workers, and Release — Persist data, run bounded background work, and ship a small service binary with repeatable checks.
- Observability and Operational Errors — Make service failures visible with structured logs, typed operational errors, request IDs, and safe response mapping.
- Deploys, Health, and Incident Runbooks — Ship Go services with health endpoints, graceful shutdown, smoke checks, and incident notes a teammate can follow.
-
Progress from modern C# API foundations to intermediate endpoint design, advanced EF Core performance, and pro-grade operations.
Typed backend - Advanced
- Modern C# API Foundations — Use records, nullable references, async methods, and options to establish reliable service contracts.
- Project Structure and Dependency Injection — Split API, application, and infrastructure responsibilities so dependency direction stays reviewable from the first feature.
- Typed Minimal APIs — Keep endpoints compact while preserving explicit result shapes and discoverable contracts.
- Validation, Auth, and Problem Details — Design endpoint filters, authorization policies, and problem responses as one consistent contract instead of scattered checks.
- EF Core Performance Boundaries — Load the data you need, track only what you change, and spot query problems before production.
- EF Core Write Transactions and Concurrency — Make write paths safe under retries, concurrency conflicts, and partial failures with explicit transaction boundaries.
- Testing, Health, and Hosted Services — Add integration tests, health checks, structured logs, and a background worker that shuts down gracefully.
- Observability, Deploys, and Incident Runbooks — Connect logs, health, metrics, release checks, and rollback decisions into an operations playbook a teammate can execute.
-
Use Rust to build service and tooling foundations with ownership, error modeling, async boundaries, and deployment confidence.
Systems reliability - Intermediate
- Ownership, Config, and Results — Use borrowing, owned return values, enums, and Result to build small reliable system components.
- Ownership in Services — Use ownership and shared state deliberately so handlers stay simple and safe.
- Error Modeling — Represent expected failures as types and keep surprising failures observable.
- CLI, Async Persistence, and Release — Create a companion CLI, persist service state with sqlx-style repositories, and run release checks.
- Tracing, Health, and Runtime Diagnostics — Expose typed health checks, tracing spans, and runtime diagnostics so async Rust services can be debugged under load.
- Release Packaging and Operations Runbooks — Prepare a Rust service and CLI for handoff with cargo checks, binary packaging, config examples, smoke tests, and rollback notes.