TypeDrop
Challenge Archive
| Date | Difficulty | Challenge | Description | |
|---|---|---|---|---|
| 2026-06-11 | Medium | Typed Real-Time Sensor Stream Aggregator | You're building the ingestion layer for an IoT monitoring platform. Raw sensor readings arrive as `unknown` from a WebSocket feed; your engine must validate them, group them by device and metric type via a strongly-typed pipeline, and produce a per-device aggregated summary — with zero `any`. | See |
| 2026-06-10 | Easy | Typed Shopping Cart Discount Engine | You're building the checkout engine for an e-commerce platform. Cart items arrive as `unknown` from a storefront API; your engine must validate them, apply the correct typed discount rule to each item, and return a strongly-typed order summary — with zero `any`. | See |
| 2026-06-09 | Medium | Typed Job Queue Scheduler with Priority & Concurrency | You're building the background-job engine for a data-processing platform. Raw job definitions arrive as `unknown` from a REST API; your scheduler must validate them, dispatch jobs by priority through a typed concurrency-limited runner, and return a strongly-typed execution report — with zero `any`. | See |
| 2026-06-08 | Hard | Typed Plugin Middleware Chain Executor | You're building the request-processing core for an API gateway platform where operators compose pipelines of plugins (auth, rate-limiting, transformation, logging) loaded at runtime from `unknown` JSON configuration. Each plugin is resolved through a typed registry, executed as an ordered async middleware chain with per-plugin timeout enforcement, and the entire run produces a strongly-typed execution trace — with zero `any`. | See |
| 2026-06-07 | Medium | Typed Event Log Aggregator with Discriminated Unions | You're building the analytics layer for a SaaS platform's audit dashboard. Raw event log entries stream in as `unknown` from a Kafka consumer; your engine must validate them, narrow each to its correct discriminated-union variant, and produce a strongly-typed per-user activity summary — with zero `any`. | See |
| 2026-06-06 | Hard | Typed Paginated API Client with Retry & Result Monad | You're building the data-access layer for an analytics dashboard that pulls records from a paginated third-party REST API. The API is unreliable — responses arrive as `unknown`, pages must be fetched concurrently up to a configurable limit, transient failures must be retried with exponential back-off, and every outcome must be surfaced through a typed `Result<T, E>` monad — with zero `any`. | See |
| 2026-06-05 | Easy | Typed Recipe Ingredient Scaler | You're building the recipe engine for a meal-planning app. Raw recipe data arrives as `unknown` from a third-party nutrition API; your engine must validate it, scale each ingredient's quantity to a requested serving size, and return a strongly-typed scaled recipe — with zero `any`. | See |
| 2026-06-04 | Medium | Typed Product Inventory Aggregator | You're building the reporting layer for an e-commerce warehouse system. Raw inventory records arrive as `unknown` JSON from a legacy ERP API; your engine must validate them, apply category-level discount rules via a typed strategy registry, and produce a strongly-typed per-category stock summary — with zero `any`. | See |
| 2026-06-03 | Hard | Typed Workflow State Machine Executor | You're building the execution engine for a no-code automation platform where users define multi-step workflows as JSON. Raw workflow definitions arrive as `unknown` from a REST API; your engine must validate them, execute each step through a typed strategy registry, enforce per-step retry logic with exponential back-off, and produce a strongly-typed execution report — with zero `any`. | See |
| 2026-06-02 | Easy | Typed Contact Book Grouper | You're building the display layer for a mobile contact book app. Raw contact entries arrive as `unknown` from a device sync API; your engine must validate them, normalize their data, and group them into a strongly-typed alphabetical index — with zero `any`. | See |
| 2026-06-01 | Hard | Typed Real-Time Event Stream Aggregator | You're building the ingestion layer for a live operations monitoring platform. Raw telemetry events arrive as `unknown` over a simulated stream; your engine must validate them into a discriminated-union event type, route them through per-kind typed reducer functions, enforce a sliding time-window deduplication strategy, and produce a strongly-typed per-source aggregation report — with zero `any`. | See |
| 2026-05-31 | Medium | Typed Permission-Based Access Control Engine | You're building the authorization layer for a multi-tenant SaaS platform. Unknown user session tokens arrive from an authentication provider; your engine must validate them, resolve role-based permissions via a typed policy registry, and produce a strongly-typed access decision report — with zero `any`. | See |
| 2026-05-30 | Hard | Typed Paginated API Cursor Engine | You're building the data-fetching layer for a large-scale analytics dashboard that must stream millions of records from a paginated REST API. Pages arrive as `unknown` JSON; your engine must validate them, thread opaque cursors through sequential fetches, enforce concurrency limits across multiple resource streams, and surface a strongly-typed per-resource aggregation report — with zero `any`. | See |
| 2026-05-29 | Easy | Typed Shopping Cart Aggregator | You're building the order-summary layer for an e-commerce checkout flow. Raw cart items arrive as `unknown` from a localStorage deserializer; your engine must validate them, apply typed discount rules, and produce a strongly-typed order summary — with zero `any`. | See |
| 2026-05-28 | Medium | Typed Middleware Pipeline Builder | You're building the request-processing layer for an internal API gateway. Incoming requests pass through a chain of typed middleware handlers — each one can enrich the context, short-circuit with a typed error, or pass control to the next handler — all with zero `any`. | See |
| 2026-05-27 | Hard | Typed Retry-with-Backoff Fetch Orchestrator | You're building the resilient data-fetching layer for a financial trading dashboard. External market-data endpoints are flaky; your orchestrator must validate raw responses, retry failed requests with typed exponential back-off policies, fan out concurrent calls within a concurrency cap, and surface a strongly-typed per-endpoint result report — with zero `any`. | See |
| 2026-05-26 | Medium | Typed Event Aggregator with Discriminated Union Streams | You're building the analytics ingestion layer for a real-time monitoring dashboard. Raw telemetry events arrive as `unknown` from a WebSocket feed; your engine must validate them, fan them into typed streams by category, and produce a strongly-typed per-category summary report — with zero `any`. | See |
| 2026-05-25 | Easy | Typed User Permission Checker | You're building the access-control layer for a SaaS dashboard. Raw user session data arrives as `unknown` from a JWT-decode utility; your engine must validate it, derive a typed permission set from the user's role, and answer permission queries — with zero `any`. | See |
| 2026-05-24 | Hard | Typed Paginated API Client with Cursor-Based Aggregation | You're building the data-ingestion layer for an analytics dashboard that pulls user activity events from a cursor-paginated REST API. Pages arrive as `unknown`; your client must validate each page, fan out concurrent fetches up to a concurrency limit, aggregate results through a typed single-pass reducer, and surface a strongly-typed report — with zero `any`. | See |
| 2026-05-23 | Easy | Typed Task Priority Queue | You're building the scheduling layer for a project management tool. Tasks arrive as `unknown` from a REST API; your engine must validate them, insert them into a typed priority queue, and drain them in order — returning a strongly-typed execution plan with zero `any`. | See |
| 2026-05-22 | Hard | Typed Middleware Pipeline with Typed Context & Error Boundaries | You're building the request-processing core for a high-throughput HTTP gateway. Incoming requests pass through a chain of typed middleware layers — auth, rate-limiting, transformation, and logging — each of which can enrich a shared context object or short-circuit the pipeline with a strongly-typed error. The hardest part is making the context type accumulate correctly as it flows through each middleware stage. | See |
| 2026-05-21 | Easy | Typed Recipe Ingredient Scaler | You're building the recipe engine for a meal-planning app. Raw recipe data arrives as `unknown` from a third-party nutrition API; your engine must validate it, scale ingredient quantities to a target serving count, and return a strongly-typed scaled recipe summary — with zero `any`. | See |
| 2026-05-20 | Medium | Typed Event Bus with Subscriber Registry | You're building the internal messaging backbone for a collaborative document editor. UI components publish strongly-typed domain events; other components subscribe to specific event kinds and must receive exactly the right payload shape — with zero `any`. | See |
| 2026-05-19 | Hard | Typed Workflow State Machine with Retry & Cancellation | You're building the job-execution engine for a distributed task platform. Jobs arrive as `unknown` from a queue API; your engine must validate them, drive each job through a strict discriminated-union state machine, execute steps with typed retry logic and AbortController cancellation, and return a strongly-typed execution report — with zero `any`. | See |
| 2026-05-18 | Easy | Typed Product Inventory Grouper | You're building the catalog layer for an e-commerce platform. Raw product entries arrive as `unknown` from a warehouse API; your engine must validate them, group them by category, and return a strongly-typed per-category inventory summary — with zero `any`. | See |
| 2026-05-17 | Medium | Typed Paginated API Client with Result Handling | You're building the data-access layer for a developer dashboard that fetches issues from a project-management API. Responses arrive as `unknown` from a generic HTTP transport; your client must validate each page, accumulate results across pages, and return a strongly-typed aggregation report — with zero `any`. | See |
| 2026-05-16 | Easy | Typed User Session Aggregator | You're building the analytics layer for a SaaS dashboard. Raw session events arrive as `unknown` from a browser telemetry API; your engine must validate them, group them by user, and return a strongly-typed per-user session summary report — with zero `any`. | See |
| 2026-05-15 | Hard | Typed Streaming ETL Pipeline with Middleware | You're building the data-ingestion layer for a real-time analytics platform. Raw records stream in as `unknown` from heterogeneous sources; your typed ETL pipeline must validate them, pass them through a composable middleware chain (transform, enrich, filter), execute stages with a concurrency limit, and emit a strongly-typed pipeline report — with zero `any`. | See |
| 2026-05-14 | Easy | Typed Blog Post Tag Index | You're building the content-discovery layer for a blogging platform. Raw post entries arrive as `unknown` from a CMS API; your engine must validate them, build a typed reverse index from tags to posts, and return a strongly-typed tag summary report — with zero `any`. | See |
| 2026-05-13 | Hard | Typed Async Job Scheduler with Priority Queues | You're building the task-execution layer for a distributed background-job platform. Raw job definitions arrive as `unknown` from multiple producer services; your scheduler must validate them, enqueue them into typed priority queues, execute batches with a concurrency limit and per-job timeout, and return a strongly-typed execution report — with zero `any`. | See |
| 2026-05-12 | Easy | Typed Product Inventory Filter | You're building the catalog layer for an e-commerce platform. Raw product entries arrive as `unknown` from a third-party supplier feed; your engine must validate them, apply typed filter criteria, and return a strongly-typed filtered inventory report — with zero `any`. | See |
| 2026-05-11 | Hard | Typed Distributed Circuit Breaker | You're building the resilience layer for a microservices gateway. Each downstream service is protected by a typed circuit breaker that transitions through states based on failure thresholds; your engine must validate raw service configs arriving as `unknown`, manage per-service breaker state machines, execute calls with retry + timeout logic, and return a strongly-typed health report — with zero `any`. | See |
| 2026-05-10 | Easy | Typed User Session Aggregator | You're building the analytics layer for a SaaS dashboard. Raw session events arrive as `unknown` from a client-side tracking SDK; your engine must validate them, group them by user, and return a strongly-typed per-user session summary — with zero `any`. | See |
| 2026-05-09 | Hard | Typed Streaming ETL Pipeline | You're building the data-ingestion layer for a real-time analytics platform. Raw event batches arrive as `unknown` from multiple upstream sources; your pipeline must validate them, transform each event through a typed middleware chain, fan-out to per-topic async sinks with a concurrency limit, and return a strongly-typed pipeline execution report — with zero `any`. | See |
| 2026-05-08 | Easy | Typed Recipe Nutrition Aggregator | You're building the nutrition-analysis layer for a meal-planning app. Raw recipe payloads arrive as `unknown` from a third-party food database API; your engine must validate them, aggregate per-serving nutrition totals, and return a strongly-typed nutrition summary — with zero `any`. | See |
| 2026-05-07 | Medium | Typed Job Queue Scheduler | You're building the background-job layer for a workflow automation platform. Raw job definitions arrive as `unknown` from a user-facing API; your scheduler must validate them, assign each job to a typed priority lane, execute lanes with a configurable concurrency limit, and return a strongly-typed execution report — with zero `any`. | See |
| 2026-05-06 | Easy | Typed Product Inventory Filter | You're building the catalog layer for an e-commerce storefront. Raw product entries arrive as `unknown` from a third-party supplier feed; your engine must validate them, apply typed filter criteria, and return a strongly-typed filtered inventory summary — with zero `any`. | See |
| 2026-05-05 | Medium | Typed Notification Dispatcher | You're building the notification layer for a multi-channel SaaS platform. Raw notification payloads arrive as `unknown` from an internal message bus; your dispatcher must validate them, route each to the correct typed handler via a discriminated union, execute all handlers with a per-channel retry policy, and return a strongly-typed dispatch report — with zero `any`. | See |
| 2026-05-04 | Easy | Typed Expense Report Builder | You're building the expense-reporting layer for a travel management app. Raw expense entries arrive as `unknown` from an employee submission form; your engine must validate them, group them by category, and return a strongly-typed report summary — with zero `any`. | See |
| 2026-05-03 | Medium | Typed In-Memory Search Index | You're building the client-side search layer for a documentation site. Raw document payloads arrive as `unknown` from a local JSON bundle; your engine must validate them, build an inverted index over configurable fields, and return strongly-typed ranked results — with zero `any`. | See |
| 2026-05-02 | Easy | Typed Event RSVP Aggregator | You're building the guest-management layer for an event-planning app. Raw RSVP payloads arrive as `unknown` from a public form endpoint; your aggregator must validate them, tally attendance per event, and return a strongly-typed summary — with zero `any`. | See |
| 2026-05-01 | Hard | Typed Workflow Orchestrator | You're building the execution engine for a low-code automation platform. User-defined workflow definitions arrive as `unknown` from a configuration store; your orchestrator must validate them, topologically sort their steps into dependency-respecting execution stages, run each stage with typed retry/timeout policies, and emit a discriminated-union execution report per step — with zero `any`. | See |
| 2026-04-30 | Medium | Typed Paginated API Client | You're building the data-fetching layer for an analytics dashboard that consumes a paginated REST API. Raw page responses arrive as `unknown` from the network; your client must validate each page, lazily accumulate results with a configurable concurrency limit, and surface a discriminated-union outcome per fetch — with zero `any`. | See |
| 2026-04-29 | Easy | Typed Shopping Cart Aggregator | You're building the order summary engine for an e-commerce storefront. Raw cart payloads arrive as `unknown` from a client-side checkout form; your engine must validate them, compute per-line totals with applied discounts, and return a strongly-typed order summary — with zero `any`. | See |
| 2026-04-28 | Hard | Typed API Rate-Limiter Middleware Chain | You're building the gateway middleware layer for a multi-tenant REST API platform. Raw inbound requests arrive as `unknown` from the network edge; your engine must validate them, route each request through a composable chain of strongly-typed rate-limiter strategies (token bucket, sliding window, concurrency cap), and emit a discriminated-union decision — with zero `any`. | See |
| 2026-04-27 | Easy | Typed Notification Router | You're building the notification dispatch layer for a productivity app. Raw notification payloads arrive as `unknown` from a webhook endpoint; your router must validate them, fan them out to strongly-typed per-channel handlers, and collect a discriminated-union delivery report per notification — with zero `any`. | See |
| 2026-04-26 | Hard | Typed Real-Time Metrics Aggregator | You're building the telemetry ingestion pipeline for a distributed observability platform. Raw metric events arrive as `unknown` from multiple instrumentation agents; your engine must validate them, route each event to a strongly-typed aggregator strategy, perform single-pass windowed aggregation with concurrency-safe flushing, and emit a discriminated-union report per metric series — with zero `any`. | See |
| 2026-04-25 | Medium | Typed Job Queue Processor | You're building the background job processing engine for a task automation platform. Raw job payloads arrive as `unknown` from a message broker; your processor must validate them, dispatch each job to a strongly-typed handler, enforce per-job-type retry policies, and produce a discriminated-union result per job — with zero `any`. | See |
| 2026-04-24 | Hard | Typed Permission Policy Evaluator | You're building the authorization engine for a multi-tenant SaaS platform. Raw policy documents arrive as `unknown` JSON from an admin dashboard; your engine must validate them, compile each rule into a strongly-typed decision graph, evaluate access requests against matching policies using precedence logic, and emit a discriminated-union verdict per request — with zero `any`. | See |
| 2026-04-23 | Easy | Typed Shopping Cart Aggregator | You're building the order summary engine for a small e-commerce storefront. Raw cart line items arrive as `unknown` JSON from the client; your engine must validate them, apply typed discount rules, and produce a strongly-typed order summary — with zero `any`. | See |
| 2026-04-22 | Medium | Typed API Response Cache | You're building the caching layer for a typed REST API client used across a large frontend monorepo. Raw responses arrive as `unknown` from fetch; your cache must validate them, store them with TTL-aware entries, and serve requests through a stale-while-revalidate strategy — with zero `any`. | See |
| 2026-04-21 | Hard | Typed Schema Migration Engine | You're building the schema migration engine for a multi-tenant database platform. Raw migration manifests arrive as `unknown` JSON from a CI/CD pipeline; your engine must validate them, compile each migration into a strongly-typed dependency graph, execute migrations in topological order with concurrency limits and rollback support, and emit a discriminated-union result per migration — with zero `any`. | See |
| 2026-04-20 | Medium | Typed Event Stream Aggregator | You're building the real-time analytics backend for a product telemetry platform. Raw event objects arrive as `unknown` from a WebSocket feed; your aggregator must validate them, route them to per-event-type handlers, and produce a strongly-typed session summary — with zero `any`. | See |
| 2026-04-19 | Hard | Typed Workflow Orchestrator | You're building the workflow execution engine for a low-code automation platform. Raw workflow definitions arrive as unknown JSON from a user-facing editor; your orchestrator must validate them, compile each step into a strongly-typed execution graph, run steps with concurrency limits and retry logic, and emit a discriminated-union result per step — with zero `any`. | See |
| 2026-04-18 | Medium | Typed Notification Router | You're building the notification dispatch layer for a multi-channel messaging platform. Raw notification payloads arrive as unknown JSON from a message queue; your router must validate them, fan-out to the correct typed channel handlers, and produce a structured per-recipient delivery report — with zero `any`. | See |
| 2026-04-17 | Hard | Typed Query Plan Builder | You're building the query planning layer for an in-memory analytics engine. Raw query descriptors arrive as unknown JSON from a REST API; your planner must validate them, compile them into a strongly-typed execution plan through a composable operator pipeline, execute each operator with typed intermediate results, and surface a discriminated-union outcome per stage — with zero `any`. | See |
| 2026-04-16 | Medium | Typed API Rate Limiter | You're building the outbound API gateway for a SaaS integration platform. Multiple services make concurrent requests to third-party APIs with different rate limits; your gateway must validate raw endpoint configurations, enforce per-client token-bucket limits, execute requests with typed results, and return a structured dispatch report — with zero `any`. | See |
| 2026-04-15 | Easy | Typed CSV Report Parser | You're building the data-import pipeline for a sales analytics dashboard. Raw CSV text arrives from uploaded files as plain strings; your parser must validate each row, transform it into a strongly-typed record, and return a typed parse report — with zero `any`. | See |
| 2026-04-14 | Medium | Typed Feature Flag Evaluator | You're building the feature-flag evaluation engine for a product experimentation platform. Raw flag configurations arrive from a remote config service as unknown JSON; your engine must validate them, evaluate each flag against a typed user context, and return a strongly-typed rollout report — with zero `any`. | See |
| 2026-04-13 | Hard | Typed Workflow Orchestrator | You're building the execution engine for a low-code automation platform. Raw workflow definitions arrive as unknown JSON blobs from a database; your orchestrator must validate them, compile them into a strongly-typed execution graph, run steps through a typed middleware pipeline with retry logic, and surface a discriminated-union result per step — with zero `any`. | See |
| 2026-04-12 | Medium | Typed Notification Dispatcher | You're building the notification delivery layer for a team collaboration app. Raw notification payloads arrive from a message broker as unknown blobs; your dispatcher must validate them, route them through a registry of typed channel handlers, and return a fully typed delivery report — with zero `any`. | See |
| 2026-04-11 | Hard | Typed Event Sourcing Ledger | You're building the audit-log replay engine for a fintech platform. Raw domain events arrive as unknown JSON streams; your engine must validate them, fold them into a strongly-typed account ledger via a discriminated-union event bus, and expose a typed projection API — with zero `any`. | See |
| 2026-04-10 | Easy | Typed Task Queue Scheduler | You're building the background job runner for a productivity app. Raw task definitions arrive from a local database as unknown blobs; your scheduler must validate them, sort them by priority and deadline, and return a fully typed execution plan — with zero `any`. | See |
| 2026-04-09 | Medium | Typed API Pagination Crawler | You're building the data-sync layer for a SaaS dashboard that must pull all records from a paginated REST API. Pages arrive as unknown JSON; your crawler must validate each page, fetch all pages concurrently up to a limit, and aggregate the results into a fully typed report — with zero `any`. | See |
| 2026-04-08 | Easy | Typed Shopping Cart Summarizer | You're building the checkout screen for an e-commerce app. Raw cart items arrive from local storage as unknown blobs; your engine must validate them, apply typed discount rules, and return a fully typed order summary — with zero `any`. | See |
| 2026-04-07 | Hard | Typed Query Plan Optimizer | You're building the query execution layer for an in-browser analytics engine. Raw query descriptors arrive as unknown JSON; your optimizer must validate them, build a typed expression tree, walk it with a recursive visitor, and return a fully typed execution plan with cost estimates — with zero `any`. | See |
| 2026-04-06 | Easy | Typed Contact Book Grouper | You're building the "All Contacts" view for a mobile address book app. Raw contact entries arrive from storage as unknown blobs; your engine must validate them, group them by the first letter of their last name, and return a fully typed alphabetical index — with zero `any`. | See |
| 2026-04-05 | Medium | Typed Event Stream Aggregator | You're building the real-time analytics engine for a live-streaming platform. Raw events arrive as unknown JSON blobs from multiple sources; your engine must validate them, fan out processing concurrently with a limit, and aggregate per-stream statistics into a fully typed report — with zero `any`. | See |
| 2026-04-04 | Hard | Typed Workflow State Machine | You're building the order-fulfillment engine for a logistics platform. Every order moves through a strict lifecycle — and your state machine must enforce legal transitions at the type level, accumulate a typed audit log, and return exhaustively-matched `Result<T, E>` outcomes, all with zero `any`. | See |
| 2026-04-04 | Easy | Typed User Profile Merger | You're building the account-settings feature for a SaaS app. When a user submits a partial profile update, your engine must validate the raw incoming fields, deep-merge them onto the existing profile, and return a fully typed `Result<T, E>` — with zero `any`. | See |
| 2026-04-01 | Medium | Typed Notification Dispatcher | You're building the notification service for a SaaS platform. The system must dispatch typed notifications across multiple channels (email, SMS, push), fan out deliveries concurrently with a configurable limit, and collect a fully typed per-channel Result for every recipient — with zero `any`. | See |
| 2026-03-31 | Easy | Typed Product Inventory Filter & Sorter | You're building the catalog browsing feature for an e-commerce storefront. Shoppers can filter products by category, availability, and price range, then sort the results — your engine must validate raw catalog inputs and return a fully typed filtered and sorted result with zero `any`. | See |
| 2026-03-30 | Medium | Typed API Response Paginator | You're building the data-fetching layer for an analytics dashboard that consumes a paginated REST API. The client must fetch pages sequentially or in parallel up to a concurrency limit, validate each raw response at runtime, and aggregate all records into a typed `Result<T, E>` — with clean handling for partial failures. | See |
| 2026-03-29 | Easy | Typed Recipe Ingredient Scaler | You're building the recipe customization feature for a cooking app. Users can scale any recipe up or down by a multiplier, and your engine must validate raw ingredient inputs, convert between units, and return a fully typed scaled recipe — with zero `any`. | See |
| 2026-03-28 | Hard | Typed Event-Sourced State Machine | You're building the order-lifecycle engine for a commerce platform. Orders move through a strict set of states via typed events — your state machine must enforce legal transitions at the type level, fold an event log into the current state, and surface a fully typed `Result<T, E>` for every operation with zero `any`. | See |
| 2026-03-27 | Easy | Typed Student Grade Book Aggregator | You're building the reporting module for an online learning platform. Teachers submit raw grade entries for students across multiple subjects, and your aggregator must validate the entries, compute per-student summaries, and assign letter grades — all with fully typed inputs and outputs. | See |
| 2026-03-26 | Medium | Typed Job Queue Retry Scheduler | You're building the background job processing layer for a workflow automation platform. Jobs can succeed, fail with a retryable error, or fail fatally — your scheduler must execute them with typed retry policies, collect per-job outcomes, and surface a structured run report through a `Result<T, E>` type with zero `any`. | See |
| 2026-03-25 | Easy | Typed Product Catalog Filter & Sorter | You're building the browse experience for a small e-commerce storefront. Shoppers can filter products by category, price range, and availability, then sort the results — your engine must validate raw filter inputs and return a fully typed, sorted product list. | See |
| 2026-03-24 | Medium | Typed Paginated API Response Aggregator | You're building the data-sync layer for a dashboard that pulls records from a paginated REST API. The fetcher must handle typed pages, collect results across all pages with a concurrency limit, and surface either a fully aggregated dataset or a structured `Result<T, E>` error — with zero `any`. | See |
| 2026-03-23 | Hard | Typed Plugin Middleware Chain Executor | You're building the extensibility core for a developer platform where third-party plugins can register typed middleware that transforms a shared request context. Each plugin declares the exact context shape it reads and the shape it writes, and the chain executor must thread them together in order — surfacing typed errors and a full execution trace through a `Result<T, E>` monad with zero `any`. | See |
| 2026-03-22 | Medium | Typed Notification Dispatch Router | You're building the notification layer for a SaaS platform. Users can subscribe to different channels (email, SMS, push), and your router must validate raw subscription configs, fan out typed messages to each channel's handler, and collect a structured per-channel delivery report — surfaced through a `Result<T, E>` type with zero `any`. | See |
| 2026-03-21 | Easy | Typed Expense Report Aggregator | You're building the expense reporting module for a small business finance tool. Employees submit raw expense entries from a form, and your engine must validate them, tag each with a derived reimbursement status, and produce a grouped, fully typed summary — with zero `any`. | See |
| 2026-03-20 | Hard | Typed Workflow State Machine Executor | You're building the automation backbone for a CI/CD platform. Each pipeline is a finite state machine whose transitions are guarded by typed conditions, carry typed payloads, and emit strongly-typed side-effect events — all resolved through a `Result<T, E>` monad with exhaustive error handling and zero `any`. | See |
| 2026-03-19 | Easy | Typed Task Priority Queue | You're building the task management feature for a lightweight project tool. Users submit raw task entries, and your engine must validate them, assign a computed urgency tier, and serve them back in priority order — all with zero `any`. | See |
| 2026-03-18 | Medium | Typed API Pagination Cursor Engine | You're building the data-fetching layer for an analytics dashboard that loads large datasets from a paginated REST API. Each resource type has its own shape, and the engine must handle cursor-based pagination, typed per-resource response validation, and aggregation into a single fully-typed result — surfaced through a `Result<T, E>` type with zero `any`. | See |
| 2026-03-17 | Easy | Typed Book Club Reading List Builder | You're building the reading list feature for a book club app. Members submit raw book entries from a form, and you must validate them, tag each book with a derived reading status, and produce a sorted, fully typed reading list — with zero `any`. | See |
| 2026-03-16 | Medium | Typed Notification Preference Engine | You're building the notification settings module for a SaaS platform. Users configure per-channel delivery rules (email, SMS, push), and your engine must validate raw unknown config payloads, merge them with system-level defaults, and produce a resolved, strongly-typed preference map — surfaced through a `Result<T, E>` type so callers can handle every failure mode explicitly. | See |
| 2026-03-15 | Hard | Typed Real-Time Event Stream Processor | You're building the analytics backbone for a live dashboard that ingests a heterogeneous stream of server-sent events (user actions, system alerts, and metric snapshots). Each event must be parsed from raw `unknown` input, routed through a typed middleware pipeline, and aggregated into a strongly-typed per-event-kind summary — all with zero `any`. | See |
| 2026-03-14 | Easy | Typed Recipe Ingredient Scaler | You're building the recipe feature for a meal-planning app. Users can scale any recipe up or down by a multiplier, and your job is to parse raw unknown ingredient data, convert quantities to a common unit system, and return a fully typed scaled ingredient list — with zero `any`. | See |
| 2026-03-13 | Hard | Typed Concurrent Task Scheduler with Priority Queues | You're building the background job engine for a data-pipeline platform. Tasks arrive with a priority level and resource tags, must be executed with a concurrency cap per resource group, and every outcome — success, failure, or cancellation — must be surfaced through a fully typed Result hierarchy with zero `any`. | See |
| 2026-03-12 | Easy | Typed Expense Report Summariser | You're building the finance module for a small business app. Raw expense entries arrive as unknown JSON from a mobile upload, and you must validate them, categorise them, and produce a per-category summary — all with zero `any` and fully typed results. | See |
| 2026-03-11 | Medium | Typed Paginated API Client with Result Chaining | You're building the data-fetching layer for an admin dashboard that pulls paginated records from a REST API. Each page arrives as raw `unknown` JSON, must be validated into a typed shape, and pages must be lazily fetched until exhausted — all surfaced through a `Result<T, E>` type so callers never face surprise runtime exceptions. | See |
| 2026-03-10 | Easy | Typed Contact Book Merger | You're building the import feature for a personal CRM app. Users can sync contacts from multiple sources (phone, email, LinkedIn), and your job is to validate raw unknown input, merge duplicate contacts by email, and produce a clean, strongly-typed contact list — all with zero `any`. | See |
| 2026-03-09 | Hard | Typed State Machine Executor with Transition Guards | You're building the order-lifecycle engine for a fulfilment platform. Each order moves through a strict set of states (e.g. `pending → confirmed → shipped → delivered`), and every transition must pass a typed guard before it fires. The engine must enforce exhaustive state/event coverage at the type level, accumulate a typed audit log, and surface a discriminated `Result` for every attempted transition — with zero `any`. | See |
| 2026-03-08 | Easy | Typed Inventory Aggregator | You're building the stock-management module for an e-commerce back-office. Raw inventory records arrive from multiple warehouses and must be validated, grouped by category, and summarised — all with zero `any` and fully typed results. | See |
| 2026-03-07 | Medium | Typed Job Queue with Retry Logic & Concurrency Limits | You're building the background job runner for a SaaS platform. Jobs arrive with different payloads and priorities, each handler is typed to its payload, and the runner must enforce a concurrency cap, retry failed jobs with exponential back-off, and report a typed summary when the queue drains. | See |
| 2026-03-06 | Hard | Typed Real-Time Event Aggregator with Windowed Metrics | You're building the analytics backbone of a live-streaming platform. Raw telemetry events (views, reactions, chat messages, errors) arrive in bursts and must be funnelled through a strongly-typed aggregation pipeline that groups them into fixed time windows, computes per-event-kind statistics, and surfaces a typed Result for every query — all with zero `any`. | See |
| 2026-03-05 | Medium | Typed Paginated API Client with Result Chaining | You're building the data-fetching layer for an admin dashboard that queries a paginated REST API. Each endpoint returns a different resource shape, and the client must transparently walk pages, accumulate results, and surface typed errors — all without a single `any`. | See |
| 2026-03-04 | Hard | Typed Plugin Middleware Chain with Typed Error Hierarchy | You're building the request-processing core of an API gateway. Incoming requests pass through a chain of strongly-typed middleware plugins (auth, rate-limiting, transformation, logging). Each plugin can either pass the request downstream, short-circuit with a typed error, or mutate the request context — and the orchestrator must collect per-plugin results, surface a typed error hierarchy, and guarantee exhaustive handling at every exit point. | See |
| 2026-03-03 | Medium | Typed Workflow State Machine | You're building the order-processing engine for a fulfilment platform. Each order moves through a strict lifecycle — from placement to delivery or cancellation — and only certain transitions are legal at any given state. The challenge is encoding that lifecycle entirely in the type system so that illegal transitions are caught at compile time, not at runtime. | See |
| 2026-03-02 | Easy | Typed Contact Book with Safe Parsing & Lookup | You're building a lightweight contact management module for a small business app. Raw contact data arrives as unknown JSON from an import file, and you must validate it into strongly-typed records, build an efficient lookup index, and expose typed query helpers — all without reaching for `any`. | See |
| 2026-03-01 | Hard | Typed Distributed Cache with TTL & Eviction Policies | You're building the caching layer for a high-throughput microservice platform. Each cache namespace has its own value shape, TTL strategy, and eviction policy — and the orchestrator must coordinate reads, writes, and invalidations across multiple namespaces with full compile-time safety on every key-value pair. | See |
| 2026-02-28 | Medium | Typed Event Aggregator with Windowed Rollups | You're building the analytics backbone of a real-time dashboard for a SaaS platform. Raw telemetry events (page views, clicks, errors, purchases) stream in continuously, and the dashboard needs per-event-type rollups aggregated over fixed time windows — all with zero `any` and full type safety on every event shape and its aggregated form. | See |
| 2026-02-27 | Hard | Typed Paginated API Client with Retry & Concurrency | You're building a typed data-ingestion pipeline for an analytics platform. Remote REST endpoints return paginated results, requests can fail transiently, and multiple endpoints must be fetched in parallel — but with a concurrency cap to avoid hammering the servers. | See |
| 2026-02-26 | Easy | Typed Product Inventory Aggregator | You're building a back-office tool for an e-commerce warehouse. Raw inventory records arrive as unknown JSON, and you must safely validate them, group them by category, and compute per-category summaries — the challenge is keeping every step fully typed without reaching for `any`. | See |
| 2026-02-25 | Medium | Typed Middleware Pipeline Builder | You're building the request-handling core of an internal HTTP gateway. Middleware functions transform a typed context object one step at a time — the challenge is composing them into a pipeline where each middleware's output type flows into the next middleware's input type, all enforced at compile time. | See |
| 2026-02-24 | Easy | Typed Contact Book Lookup | You're building a small contact book utility for an internal HR tool. Given a list of contacts with varying optional fields, you must build a strongly-typed lookup index and implement search/filter helpers — the challenge is in the types, not the logic. | See |
| 2026-02-23 | Hard | Typed Reactive State Machine | You're building the core of a checkout flow for an e-commerce platform. The checkout process moves through well-defined states (idle → validating → payment → confirmed / failed), and every transition must be explicitly allowed, carry typed payloads, and notify strongly-typed subscribers — all enforced at compile time. | See |
| 2026-02-22 | Easy | Typed Event Log Parser | You're building a monitoring dashboard for a cloud platform. Raw event logs arrive as untyped JSON blobs — your job is to safely parse them into a discriminated union of strongly-typed events, then aggregate counts and extract the latest timestamp per event kind. | See |
| 2026-02-21 | Hard | Paginated API Client with Typed Result Accumulation | You're building a typed API client for an analytics platform that exposes cursor-based paginated endpoints. The client must traverse all pages concurrently (up to a configurable limit), accumulate results into a strongly-typed aggregate, and surface per-page errors without aborting the entire fetch — all without a single `any` or type assertion. | See |
| 2026-02-20 | Easy | Typed Inventory Aggregator | You're building a dashboard for a small e-commerce warehouse. Given a flat list of product entries (each with a category, SKU, price, and stock count), aggregate them into a per-category summary — the hardest part is getting the TypeScript types exactly right. | See |
| 2026-02-19 | Hard | Typed Middleware Pipeline with Retry & Cancellation | You're building an internal HTTP gateway layer that processes outgoing requests through a chain of typed middleware (auth injection, logging, rate-limit headers). Each middleware can transform the request context, short-circuit with a typed error, and the pipeline runner supports per-request cancellation and automatic retry with exponential back-off. | See |