TypeDrop
Challenge Archive
| Date | Difficulty | Challenge | Description | |
|---|---|---|---|---|
| 2026-09-12 | Hard | Typed Middleware Pipeline with Typed Context & Error Propagation | You're building the request-handling core for an internal API gateway. Incoming requests flow through a chain of middleware — authentication, rate-limiting, logging, and transformation — each of which can enrich a shared typed context or short-circuit the pipeline with a structured error. The compiler must catch every invalid context mutation, missing required field, and unhandled error variant. | See |
| 2026-09-11 | Medium | Typed Paginated API Client with Retry & Result Aggregation | You're building the data-fetching layer for an analytics dashboard that pulls records from a paginated REST API. Pages must be fetched sequentially, transient errors should be retried with exponential back-off, and the final result must be a typed aggregate — all without a single `any` or unsafe cast. | See |
| 2026-09-10 | Easy | Typed Expense Splitter with Settlement Calculation | You're building the core logic for a group-trip expense-splitting app. Participants log expenses paid on behalf of the group, and the app must compute each person's net balance and produce the minimal list of cash transfers needed to settle all debts — with the compiler enforcing every shape along the way. | See |
| 2026-09-09 | Hard | Typed Graph Traversal Engine with Shortest-Path & Cycle Detection | You're building the dependency-resolution core for a monorepo build system. Packages form a directed graph of dependencies; the engine must detect circular dependencies (which would deadlock a build), compute the shortest build path between two packages, and produce a topologically sorted build order — all with the compiler enforcing every graph shape, traversal result, and error variant. | See |
| 2026-09-08 | Medium | Typed Feature-Flag Evaluation Engine | You're building the feature-flag evaluation core for a SaaS platform. Flags can be simple on/off toggles, percentage rollouts, or user-segment overrides; the evaluator must resolve the correct variant for a given user context and produce a typed audit record — all without a single `any` or unsafe cast. | See |
| 2026-09-07 | Easy | Typed Task Queue with Priority & Status Tracking | You're building the background-job manager for a lightweight project management tool. Tasks arrive with different priorities and move through a fixed lifecycle; the UI needs a typed queue that enforces valid status transitions, aggregates task counts by status, and surfaces the next task to process — all with the compiler catching every invalid shape. | See |
| 2026-09-06 | Hard | Typed Event Sourcing Engine with Snapshot Compaction & Projection Rebuilding | You're building the event-sourcing core for a collaborative document platform. Domain events arrive as a discriminated union, an append-only event log must be replayed into aggregate state via typed reducers, periodic snapshots compact history for fast rebuilds, and read-model projections subscribe to specific event subsets — all with the compiler enforcing every event shape, reducer signature, and projection contract. | See |
| 2026-09-05 | Easy | Typed Contact Book with Grouped Search & Formatted Output | You're building the contact-management module for a small business CRM. Contacts can be reached by phone, email, or both, and the UI needs to search contacts by name fragment, group results by their first letter, and format each match into a display-ready summary string — all with the compiler enforcing every shape. | See |
| 2026-09-04 | Medium | Typed HTTP Retry Client with Exponential Backoff & Error Classification | You're building the resilient HTTP layer for a microservice platform. Transient network errors and rate-limit responses should be retried with exponential backoff, while client errors (4xx) must be surfaced immediately — all with fully typed request/response shapes and a structured Result type so callers never need to guess what went wrong. | See |
| 2026-09-03 | Hard | Typed Schema-Validated ETL Pipeline with Branded Results | You're building the ingestion layer for a data-warehouse platform. Raw records arrive as `unknown` JSON blobs, must be validated against per-table schemas, transformed into strongly-typed domain rows, and either committed to a typed sink or collected into a structured error report — all without a single `any` or unsafe cast in sight. | See |
| 2026-09-02 | Easy | Typed Shopping Cart with Discount Strategy & Line-Item Aggregation | You're building the checkout engine for a small e-commerce storefront. Each cart holds typed line items, and the store supports several mutually-exclusive discount strategies (percentage off, fixed amount off, buy-X-get-Y free). The compiler must guarantee that every discount kind is fully handled and that the cart summary is always correctly typed. | See |
| 2026-09-01 | Medium | Typed Job Queue with Priority Scheduling & Retry Budgets | You're building the background-job engine for a SaaS platform. Jobs arrive with different priorities and payload shapes, each worker declares which job kinds it handles, and failed jobs must be retried up to a per-kind budget — all with the compiler catching mismatches before they reach production. | See |
| 2026-08-31 | Easy | Typed In-Memory Event Emitter with Listener Registry | You're building the event bus for a real-time dashboard application. UI components subscribe to typed events (user login, metric update, alert fired), and the compiler must guarantee that every listener receives exactly the right payload shape — no casting, no guessing. | See |
| 2026-08-30 | Medium | Typed Paginated API Client with Result Chaining & Cursor Inference | You're building the data-access layer for an internal admin dashboard that fetches paginated resources from a REST API. Each endpoint returns a different resource shape, and the client must handle cursor-based pagination, surface typed per-page results, accumulate all pages into a final collection, and propagate fetch errors without losing their structure. | See |
| 2026-08-29 | Hard | Typed Middleware Pipeline with Inferred Context Accumulation | You're building the request-handling core for an internal HTTP gateway. Middleware layers run sequentially, each one reading from — and optionally enriching — a typed context object. The compiler must guarantee that a middleware can only access fields that prior layers have already attached, and that the final handler receives the exact accumulated context type — no more, no less. | See |
| 2026-08-28 | Easy | Typed Notification Dispatcher with Discriminated Unions & Template Literal Channels | You're building the notification service for a project-management app. Users can subscribe to different event channels (email, SMS, push), and each notification type carries its own payload shape. The compiler must guarantee that every notification kind is handled, every channel is valid, and the dispatcher always returns a fully-typed delivery receipt. | See |
| 2026-08-27 | Hard | Typed GraphQL-Style Query Builder with Conditional Field Selection & Recursive Inference | You're building the typed query layer for an internal developer portal that fetches data from a REST API mirroring a GraphQL-like selection model. Consumers describe *exactly* which fields they want at compile time — including nested relations — and the return type must reflect only those selected fields, nothing more and nothing less. | See |
| 2026-08-26 | Medium | Typed CSV Report Aggregator with Schema Validation & Grouped Statistics | You're building the analytics backend for a SaaS billing platform. Raw sales CSVs arrive from multiple regional offices — each row must be validated against a typed schema, invalid rows collected as structured errors, and valid rows aggregated into per-region, per-product summaries with typed statistics. | See |
| 2026-08-25 | Hard | Typed Concurrent Task Scheduler with Priority Queues & Result Monads | You're building the background job engine for a data-pipeline platform. Jobs arrive with different priorities, resource tags, and retry budgets — the scheduler must run them concurrently up to a configurable concurrency limit, respect priority ordering, surface per-job typed results, and propagate structured errors without ever widening to `unknown` unsafely. | See |
| 2026-08-24 | Easy | Typed LRU Cache with Generic Constraints & Branded Keys | You're building a client-side cache for a recipe discovery app. Frequently-fetched recipes, user profiles, and search results all need to be memoized with an eviction policy — and each cache instance must be strongly typed to its value shape and use branded string keys to prevent accidental cross-cache lookups. | See |
| 2026-08-23 | Hard | Typed Middleware Pipeline with Branded Types & Conditional Inference | You're building the request-processing core for an internal HTTP gateway. Every incoming request passes through a chain of typed middleware — authentication, rate-limiting, body parsing, and authorization — each of which may enrich the context object or short-circuit with a typed error response. The hardest part is ensuring the TypeScript compiler tracks exactly which context properties have been added by each middleware stage, so downstream handlers never access fields that haven't been populated yet. | See |
| 2026-08-22 | Easy | Typed Event Emitter with Discriminated Union Payloads | You're building the real-time notification layer for a project management app. UI components subscribe to named events (task assigned, comment posted, status changed), and every listener must receive a payload that is already narrowed to the correct shape — no casting, no guessing. | See |
| 2026-08-21 | Medium | Typed Paginated API Client with Cursor-Based Iteration & Result Monad | You're building the data-fetching layer for a feed-based social platform. Timelines, notifications, and search results all arrive in cursor-paginated API responses — your client must iterate pages lazily, surface typed success/failure results per page, and aggregate items across pages into a single strongly-typed collection without ever widening to `unknown` unsafely. | See |
| 2026-08-20 | Easy | Typed groupBy & Aggregation with Mapped Types | You're building the analytics dashboard for a small e-commerce platform. Sales records stream in from the backend and you need to group them by a chosen key, then compute per-group summaries — all without losing type information about which keys are valid grouping fields. | See |
| 2026-08-19 | Hard | Typed Schema-Validated API Response Normalizer with Result Monad & Conditional Types | You're building the ingestion layer for a multi-source data warehouse. Raw API responses arrive as `unknown` JSON blobs from heterogeneous vendors — each with its own shape, required fields, and numeric/string quirks. Your normalizer must validate, coerce, and reshape each blob into a strongly-typed domain record, surfacing structured, exhaustively-matchable validation errors — all without a single `any` or unsafe cast. | See |
| 2026-08-18 | Medium | Typed Concurrent Task Scheduler with Priority Queues & Result Aggregation | You're building the background job runner for a data-pipeline platform. Tasks arrive with different priorities and async work functions; the scheduler must run at most N tasks concurrently, drain them in priority order, and return a strongly-typed aggregated report — successes, failures, and per-task durations — without ever widening to `unknown` unsafely or swallowing errors silently. | See |
| 2026-08-17 | Hard | Typed LRU Cache with TTL, Generics & Branded Keys | You're building the in-process caching layer for a multi-tenant SaaS platform. Every service — user sessions, feature flags, rate-limit counters — needs a cache that evicts the least-recently-used entry when full, respects per-entry TTLs, and enforces that keys are branded strings so callers can't accidentally mix cache namespaces at the type level. | See |
| 2026-08-16 | Medium | Typed Event Emitter with Discriminated Payloads | You're building the real-time notification hub for a collaborative document editor. Components across the app subscribe to strongly-typed events (cursor moves, edits, presence changes, errors) — the emitter must guarantee that every listener receives exactly the payload shape its event name promises, with no casting and no missed cases. | See |
| 2026-08-14 | Hard | Typed Middleware Pipeline with Typed Context & Error Boundaries | You're building the request-handling core for an internal API gateway. Every inbound request flows through a chain of middleware — authentication, rate-limiting, validation, transformation — each of which can enrich the shared context object, short-circuit with a typed error, or pass control to the next handler. The pipeline must be fully type-safe: each middleware declares what context properties it *reads* and what it *adds*, the compiler enforces correct ordering, and every short-circuit produces an exhaustively-matchable typed error. | See |
| 2026-08-13 | Medium | Typed Paginated API Client with Cursor-Based Iteration | You're building the data-access layer for an analytics dashboard that streams records from a paginated REST API. The API uses cursor-based pagination, returns heterogeneous resource types, and can fail mid-stream — your client must expose a strongly-typed async generator that yields individual records, handles errors as typed Results, and supports early cancellation via AbortSignal. | See |
| 2026-08-12 | Easy | Typed Safe JSON Parser with Result & Schema Validation | You're building the data-ingestion layer for a configuration management tool. Raw JSON strings arrive from multiple untrusted sources (files, environment variables, API responses) and must be safely parsed, validated against a known shape, and returned as a typed `Result<T, ParseError>` — never throwing, never widening to `unknown` without a guard. | See |
| 2026-08-11 | Hard | Typed Async Task Scheduler with Concurrency Limits & Retry | You're building the job-execution engine for a data-pipeline platform. Hundreds of heterogeneous tasks arrive at once, each with its own input/output type, priority, and retry policy — the scheduler must cap concurrent execution, retry failed tasks with typed error classification, and return a discriminated settlement record for every task so callers can exhaustively handle successes and failures without casting. | See |
| 2026-08-10 | Easy | Typed GroupBy Aggregator with Summary Statistics | You're building the reporting layer for a sales dashboard that receives a flat list of transaction records and must group them by a chosen key, then compute per-group summary statistics (count, sum, min, max, average) — all without losing the original record's type. | See |
| 2026-08-09 | Medium | Typed In-Memory LRU Cache with TTL & Typed Eviction Events | You're building a client-side caching layer for a dashboard that fetches expensive computed metrics from a backend. The cache must evict the least-recently-used entries when it hits capacity, expire entries after a configurable TTL, and emit strongly-typed eviction events so callers can react (e.g. log, re-fetch, or update UI) without casting. | See |
| 2026-08-08 | Easy | Typed Event Emitter with Discriminated Payloads | You're building the notification layer for a real-time collaboration tool. Components fire strongly-typed domain events (user joined, document edited, cursor moved) and listeners must only receive the exact payload shape for the event they subscribed to — no casting, no `any`. | See |
| 2026-08-06 | Medium | Typed Paginated API Client with Cursor-Based Iteration | You're building the data-fetching layer for an admin dashboard that consumes a paginated REST API. Responses arrive in cursor-based pages, and the client must lazily iterate through all pages, accumulate typed results, and surface per-page errors as a typed `Result<T, FetchError>` — never throwing, and never losing the shape of the resource being fetched. | See |
| 2026-08-05 | Easy | Typed Safe JSON Parser & Result Unwrapper | You're building a lightweight data-ingestion utility for a dashboard that consumes JSON payloads from third-party webhooks. Payloads can be malformed, partially missing required fields, or entirely the wrong shape — so every parse must return a typed `Result<T, ParseError>` instead of throwing, and callers must exhaustively handle both branches. | See |
| 2026-08-04 | Medium | Typed Middleware Pipeline with Context Narrowing | You're building the request-processing core for an HTTP API gateway. Each incoming request passes through a chain of middleware functions that progressively enrich a shared context object — attaching a parsed auth token, validated body, rate-limit metadata, and more — before reaching the final route handler. The hardest part is making TypeScript track exactly which properties have been added to the context at each stage, so the final handler only compiles when all required enrichments are present. | See |
| 2026-08-03 | Hard | Typed Concurrent Task Scheduler with Priority & Retry | You're building the background job engine for a data-pipeline platform. Tasks arrive with priorities, concurrency slots are limited, and flaky tasks must be retried with exponential back-off — all while the scheduler exposes a strongly-typed, generic result stream so callers never lose track of which task produced which outcome. | See |
| 2026-08-02 | Easy | Typed GroupBy & Aggregation Pipeline | You're building the reporting layer for a small e-commerce analytics dashboard. Raw order records arrive as a flat array and must be grouped by an arbitrary key, then reduced into a typed summary — all without losing type information or reaching for `any`. | See |
| 2026-08-01 | Medium | Typed In-Memory Cache with TTL & Tagged Invalidation | You're building the caching layer for a multi-tenant SaaS dashboard. Data from different domains (users, products, reports) is fetched expensively and must be cached with per-entry TTLs, but operations teams also need to bulk-invalidate all entries belonging to a logical tag (e.g. wipe every "tenant:acme" entry at once). The hardest part is keeping the cache fully generic and type-safe across heterogeneous value shapes. | See |
| 2026-07-31 | Hard | Typed Event-Sourced State Machine | You're building the order-lifecycle engine for an e-commerce platform. Orders move through a strict set of states (e.g. `Pending → Confirmed → Shipped → Delivered`, with cancellation possible from some states), and every transition must be recorded as an immutable event in an append-only log. The hardest part is making TypeScript enforce — at the type level — which events are legal from each state, so invalid transitions are caught at compile time, not at runtime. | See |
| 2026-07-30 | Medium | Typed Pagination Aggregator with Cursor-Based Fetching | You're building the data-loading layer for an analytics dashboard that must pull all records from cursor-paginated REST APIs (think GitHub, Stripe, or Notion). Each endpoint returns a typed page of items plus an opaque next-cursor, and you need a generic aggregator that fetches all pages sequentially, enforces a per-fetch timeout via AbortController, and returns a strongly-typed settled result — collected items or a structured error — without any unsafe escape hatches. | See |
| 2026-07-28 | Easy | Typed HTTP API Client Builder | You're building the typed HTTP client layer for a mobile app's backend SDK. Consumers should be able to declare their API endpoints once — including method, path params, query params, and response shape — and get back a fully-typed `fetch` wrapper with zero `any` or unsafe casts. | See |
| 2026-07-27 | Medium | Typed Retry & Concurrency-Limited Task Runner | You're building the job-execution engine for a data-pipeline orchestrator. Individual tasks are async functions that can fail transiently, so the runner must retry them with exponential back-off, enforce a global concurrency cap so the host isn't overwhelmed, and return a fully-typed settled report for every task — success value or final error — without losing the original task's return type. | See |
| 2026-07-26 | Easy | Typed Safe JSON Parser with Result Type | You're building the configuration-loading layer for a CLI tool. Raw JSON strings arrive from config files, environment variables, and remote endpoints — any of which can be malformed or structurally wrong. You need a small, strongly-typed parsing toolkit that turns `unknown` blobs into validated, shaped data without ever reaching for `any` or unsafe type assertions. | See |
| 2026-07-25 | Medium | Typed LRU Cache with TTL & Typed Eviction Callbacks | You're building the in-process caching layer for a high-traffic API server. Cached entries must expire after a configurable TTL, the cache must evict the least-recently-used entry when it reaches capacity, and callers need strongly-typed eviction callbacks so downstream systems can react (e.g. flush to disk, emit metrics) without losing the shape of the evicted value. | See |
| 2026-07-24 | Hard | Typed Event Emitter with Wildcard Subscriptions & Replay | You're building the real-time notification backbone for a collaborative document editor. Components subscribe to strongly-typed events (e.g. `"cursor:moved"`, `"doc:saved"`, `"user:joined"`), and late-joining subscribers can replay the last N events they missed — all with zero type-unsafe escape hatches. | See |
| 2026-07-23 | Easy | Typed GroupBy & Aggregation Pipeline | You're building the reporting layer for a sales dashboard. Raw transaction records need to be bucketed by an arbitrary key, then summarised with typed aggregation functions — all without losing the shape of the original data or reaching for `any`. | See |
| 2026-07-22 | Medium | Typed Paginated API Client with Result Aggregation | You're building the data-fetching layer for an analytics dashboard. The backend exposes a cursor-based paginated endpoint, and your client must walk every page, accumulate records, handle per-page errors gracefully, and surface a fully-typed aggregated result — all without losing type information or resorting to `any`. | See |
| 2026-07-21 | Hard | Typed Middleware Pipeline with Branching & Typed Context | You're building the request-processing core for an API gateway. Incoming requests flow through a chain of middleware functions that can read and write a strictly-typed context object, short-circuit the pipeline by returning an early response, or pass control to the next middleware — all while preserving full type safety across every stage of the chain. | See |
| 2026-07-20 | Medium | Typed Retry-with-Backoff Task Queue | You're building the background job runner for a data-pipeline service. Tasks arrive with typed inputs and outputs, and each task must be retried up to a configurable limit on failure — using exponential backoff — before being marked as permanently failed. The queue must surface per-task results without losing successful jobs, and the whole run must respect a shared AbortSignal for graceful shutdown. | See |
| 2026-07-19 | Hard | Typed Hierarchical State Machine | You're building the order-lifecycle engine for an e-commerce platform. Orders flow through a strict set of states (e.g. `Pending → Confirmed → Shipped → Delivered`, with `Cancelled` reachable from several states), and each transition may carry a typed payload. Your task is to implement a strongly-typed hierarchical state machine where invalid transitions are rejected at the type level, transition guards receive the correct context, and every state's entry/exit hooks are fully typed — with zero `any`. | See |
| 2026-07-18 | Easy | Typed In-Memory Event Emitter | You're building the notification hub for a real-time dashboard. UI components subscribe to named events and expect their callbacks to receive exactly the right payload shape — no more, no less. Your task is to implement a strongly-typed `EventEmitter` that maps event names to their payload types and enforces that relationship at every call site. | See |
| 2026-07-17 | Hard | Typed Dependency Injection Container | You're building the service-locator core for a backend framework. Modules register factories under typed token keys, declare their dependencies on other tokens, and the container must resolve the full dependency graph at runtime — detecting circular dependencies, enforcing that every dependency is registered before resolution, and returning a fully-typed resolved instance — all with zero `any`. | See |
| 2026-07-16 | Medium | Typed Paginated API Client with Result Accumulation | You're building the data-sync engine for an analytics dashboard that pulls records from a paginated REST API. Each page of results must be fetched sequentially, validated from `unknown` into a typed shape, and accumulated into a single `PagedResult<T>` — stopping early on fatal errors and surfacing per-page failures without losing successfully fetched data. | See |
| 2026-07-15 | Easy | Typed CSV Row Parser & Aggregator | You're building the data-import feature for a budgeting app. Raw CSV rows arrive as plain strings; your module must parse and validate each row into a strongly-typed `Transaction` record, collect typed parse errors, and then aggregate the valid rows into a per-category `SpendingSummary` — with zero `any`. | See |
| 2026-07-14 | Hard | Typed Plugin Middleware Pipeline | You're building the request-processing core for an API gateway. Plugins are registered at startup and form a typed middleware chain — each plugin declares the context fields it *reads* and *writes*, and the pipeline must enforce at the type level that every field a plugin reads has already been produced by an earlier plugin. | See |
| 2026-07-13 | Medium | Typed Retry-with-Backoff Fetcher | You're building the resilient HTTP layer for a microservice that calls third-party APIs known to occasionally return transient errors. Each request must be retried with exponential backoff, errors must be classified as retryable or fatal, and every outcome — success or exhausted retries — must be surfaced as a fully-typed `FetchResult<T>` with zero `any`. | See |
| 2026-07-12 | Hard | Typed Finite State Machine Executor | You're building the order-lifecycle engine for an e-commerce platform. Orders move through a strict set of states (Draft → Submitted → Processing → Shipped → Delivered, with cancellation paths), and every transition must be explicitly declared, guard-checked, and side-effected — all with zero runtime surprises and zero `any`. | See |
| 2026-07-11 | Easy | Typed User Notification Preferences Merger | You're building the notification settings module for a SaaS platform. Users can configure per-channel preferences (email, SMS, push), and admins can define org-level defaults. Your module must validate raw preference objects arriving as `unknown`, merge user overrides on top of org defaults, and return a fully-typed `ResolvedPreferences` record — with zero `any`. | See |
| 2026-07-10 | Medium | Typed Event Aggregator with Time-Window Bucketing | You're building the analytics ingestion layer for a real-time monitoring dashboard. Raw events arrive as `unknown` from a webhook stream; your aggregator must validate them into strongly-typed `MonitoringEvent` records, bucket them into fixed time windows, and produce a fully-typed `WindowSummary` per bucket — with zero `any`. | See |
| 2026-07-09 | Easy | Typed Task Queue Prioritizer | You're building the task scheduling module for a background job runner. Raw task definitions arrive as `unknown` from a job submission API; your module must validate them into strongly-typed `Task` records, sort them by priority and submission time, and return a fully-typed `ScheduleResult` — with zero `any`. | See |
| 2026-07-08 | Medium | Typed Paginated API Client with Result Accumulation | You're building the data-fetching layer for an analytics dashboard that pulls records from a cursor-based REST API. Raw pages arrive as `unknown` from each fetch; your client must validate each page, accumulate typed records across pages, respect a configurable item cap, and surface per-page errors without aborting the entire run — all with zero `any`. | See |
| 2026-07-07 | Hard | Typed Middleware Pipeline with Typed Context Propagation | You're building the request-processing pipeline for an API gateway. Each incoming request flows through a chain of typed middleware layers — authentication, rate-limiting, transformation, and logging — where each layer can enrich a shared typed context object, short-circuit with a typed error response, or pass control to the next handler. The hardest part is ensuring the context type is progressively widened as middleware layers run, and that error variants are exhaustively handled. | See |
| 2026-07-06 | Easy | Typed Product Inventory Filter & Summarizer | You're building the inventory management module for an e-commerce dashboard. Raw product entries arrive as `unknown` from a warehouse sync API; your module must validate them into strongly-typed `Product` records, filter them by availability and category, and return a fully-typed `InventorySummary` — with zero `any`. | See |
| 2026-07-05 | Medium | Typed Feature Flag Evaluator with Audience Targeting | You're building the feature-flag evaluation engine for a SaaS platform. Raw flag configurations arrive as `unknown` from a remote config service; your engine must validate them into strongly-typed `FeatureFlag` records, evaluate each flag against a typed `UserContext` using discriminated targeting rules, and return a fully-typed `EvaluationResult` per flag — with zero `any`. | See |
| 2026-07-04 | Easy | Typed Event RSVP Aggregator | You're building the RSVP processing module for an event management platform. Raw RSVP submissions arrive as `unknown` from a webhook; your module must validate them into strongly-typed `Rsvp` records, tally responses by status, and return a fully-typed `RsvpSummary` — with zero `any`. | See |
| 2026-07-03 | Medium | Typed Job Queue Scheduler with Priority & Retry Policies | You're building the background job scheduling engine for a distributed task platform. Raw job definitions arrive as `unknown` from a message broker; your engine must validate them into strongly-typed `Job` records, schedule them according to priority tiers, apply per-job-type retry policies, and return a fully-typed dispatch plan — with zero `any`. | See |
| 2026-07-02 | Easy | Typed Expense Report Aggregator | You're building the expense-report processing module for a finance dashboard. Raw expense entries arrive as `unknown` from a form submission API; your module must validate them into strongly-typed `Expense` records, group them by category, compute per-category and overall totals, and return a fully-typed `ExpenseReport` — with zero `any`. | See |
| 2026-07-01 | Medium | Typed API Rate Limiter with Sliding Window & Per-Client Policies | You're building the rate-limiting middleware for a multi-tenant REST API gateway. Raw inbound requests arrive as `unknown` from an HTTP adapter; your module must validate them into strongly-typed request descriptors, look up per-client policies from a typed registry, apply a sliding-window algorithm to track usage, and return a fully-typed allow/deny decision — with zero `any`. | See |
| 2026-06-30 | Easy | Typed Shopping Cart with Discount Resolution | You're building the checkout module for a small e-commerce storefront. Raw cart payloads arrive as `unknown` from the client; your module must validate them into strongly-typed `CartItem` records, apply the correct discount strategy per item category, and return a fully-typed order summary — with zero `any`. | See |
| 2026-06-29 | Medium | Typed Feature Flag Engine with Targeting Rules & Rollout Segments | You're building the feature-flag evaluation engine for a SaaS platform. Raw flag configurations arrive as `unknown` from a remote config store; your engine must validate them into strongly-typed flag definitions, evaluate targeting rules against a typed user context, and return a fully-typed evaluation result — with zero `any`. | See |
| 2026-06-28 | Easy | Typed CSV Contact Importer with Validation & Deduplication | You're building the contact-import pipeline for a CRM tool. Raw CSV rows arrive as `unknown` from a file parser; your module must validate them into strongly-typed `Contact` records, collect structured field-level errors, and deduplicate entries by email — returning a fully-typed import report with zero `any`. | See |
| 2026-06-27 | Medium | Typed Job Queue with Priority Scheduling & Retry Policies | You're building the background job processing engine for a SaaS platform. Raw job submissions arrive as `unknown` from an HTTP API; your queue must validate them into strongly-typed job descriptors, schedule them by priority, execute them through a typed handler registry, apply per-job-kind retry policies, and return a fully-typed execution receipt — with zero `any`. | See |
| 2026-06-26 | Hard | Typed Event Sourcing Engine with Snapshot & Projection | You're building the core event-sourcing engine for a financial ledger service. Raw domain events arrive as `unknown` from a Kafka consumer; your engine must validate and narrow them into a discriminated-union event log, rebuild aggregate state via typed reducers, apply snapshotting for performance, and fan-out to multiple read-model projections — all with zero `any`. | See |
| 2026-06-25 | Medium | Typed API Rate Limiter with Sliding Window & Policy Registry | You're building the rate-limiting middleware for a multi-tenant REST API gateway. Raw policy configurations arrive as `unknown` from a remote config store; your limiter must validate them, look up the correct typed policy per tenant, track request counts in a sliding-window algorithm, and return a strongly-typed admission decision — with zero `any`. | See |
| 2026-06-24 | Easy | Typed Shopping Cart with Discount Rules & Order Summary | You're building the checkout layer for a small e-commerce storefront. Cart items and discount codes arrive as raw input; your module must validate them into strongly-typed structures, apply the correct discount strategy, and return a fully-typed order summary — with zero `any`. | See |
| 2026-06-23 | Medium | Typed Feature Flag Evaluator with Targeting Rules & Rollout | You're building the feature-flag evaluation engine for a SaaS platform. Raw flag configurations arrive as `unknown` from a remote config service; your evaluator must validate them, match each flag's targeting rules against a typed user context, apply percentage-based rollouts, and return a strongly-typed evaluation report — with zero `any`. | See |
| 2026-06-22 | Hard | Typed Workflow Orchestrator with Dependency Resolution & Typed Step Registry | You're building the execution engine for a low-code automation platform. Raw workflow definitions arrive as `unknown` from a user-uploaded JSON file; your orchestrator must validate them, topologically sort steps by their declared dependencies, execute each step through a registry of strongly-typed handlers, propagate outputs between steps, and return a fully-typed execution report — with zero `any`. | See |
| 2026-06-21 | Medium | Typed Notification Dispatcher with Retry & Channel Routing | You're building the notification layer for a user-facing SaaS app. Raw notification payloads arrive as `unknown` from an internal queue; your dispatcher must validate them, route them to the correct typed channel handler (email, SMS, push), fan out deliveries concurrently, and return a strongly-typed delivery report — with zero `any`. | See |
| 2026-06-20 | Hard | Typed Event Sourcing Engine with Projection & Snapshot | You're building the event-sourcing backbone for a collaborative document editor. Raw domain events arrive as `unknown` from a Kafka consumer; your engine must validate them, apply them to a strongly-typed aggregate, maintain projections via a registry of typed reducers, and produce versioned snapshots — with zero `any`. | See |
| 2026-06-19 | Medium | Typed CSV Report Pipeline with Aggregation & Validation | You're building the data-export layer for an analytics dashboard. Raw CSV rows arrive as `unknown[]` from a file-upload parser; your pipeline must validate each row into a strongly-typed record, aggregate metrics in a single pass, and return a typed report summary — with zero `any`. | See |
| 2026-06-18 | Hard | Typed GraphQL-Style Query Planner & Resolver | You're building the query execution layer for an in-house data-graph API. Raw query documents arrive as `unknown` from an HTTP body; your planner must validate them, resolve each field through a registry of strongly-typed resolvers, fan out leaf fetches concurrently with a concurrency cap, and return a deeply-typed response tree — with zero `any`. | See |
| 2026-06-17 | Easy | Typed Shopping Cart Price Calculator | You're building the checkout feature for an e-commerce storefront. Raw cart data arrives as `unknown` from a client-side POST request; your engine must validate it, apply typed discount rules, and return a strongly-typed order summary — with zero `any`. | See |
| 2026-06-16 | Hard | Typed Permission Policy Engine with Role Inheritance | You're building the authorization layer for a multi-tenant SaaS platform. Raw policy definitions arrive as `unknown` from a configuration service; your engine must validate them, resolve role inheritance chains, evaluate typed permission checks against a request context, and produce a strongly-typed authorization decision — with zero `any`. | See |
| 2026-06-15 | Medium | Typed Job Queue Scheduler with Priority & Retry | You're building the background job processing layer for a SaaS platform. Raw job definitions arrive as `unknown` from a REST API; your scheduler must validate them, enqueue them by priority, execute them with concurrency limits, and produce a strongly-typed execution report — with zero `any`. | See |
| 2026-06-14 | Hard | Typed Workflow Orchestrator with Conditional Branching | You're building the workflow engine for a business-process automation platform. Raw workflow definitions arrive as `unknown` from a configuration API; your orchestrator must validate them, execute each step through a typed middleware pipeline, conditionally branch based on strongly-typed step outcomes, and produce a fully-typed execution trace — with zero `any`. | See |
| 2026-06-13 | Medium | Typed Event Sourcing Ledger Reconstructor | You're building the read-model layer for a fintech platform that uses event sourcing. Raw domain events arrive as `unknown` from a Kafka consumer; your reconstructor must validate them, replay them in order against a typed ledger state machine, and produce a strongly-typed account snapshot — with zero `any`. | See |
| 2026-06-12 | Easy | Typed Recipe Ingredient Scaler | You're building the recipe management feature for a meal-planning app. Raw recipe data arrives as `unknown` from a user-uploaded JSON file; 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-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 |