aichallengesafrica
Take a challenge
HomeChallengesRepsProblemsLeaderboardTake a challenge
TRACK 03

ASP.NET Core + APIs

The editor becomes C#, and the preview becomes the response your endpoint has to return.

41 challenges12 free14h of build time1 graded by running your code
Before you start

The later sprints here are about the framework, not the language — they assume you can already read and write C#. If you cannot yet, C# Foundations is the way in: six refactors covering the exact choices the rest of this track takes for granted.

C# Foundations

Six pieces of working, wrong C#. The choices every ASP.NET stage assumes you have already made.

  1. The wrong containerA lookup that scans a list inside a loop. Index it once instead.Beginner · 15 min
  2. Loops that want to be LINQA hand-rolled group-and-total. Say what you want instead of how to get it.Beginner · 18 min
  3. Where null gets inCode that passes every test and throws in production. Make the compiler find it.Beginner · 18 min
  4. Blocking the thread.Result, async void and Thread.Sleep in one method. Undo all three.Beginner · 20 min · Pro
  5. Types that say what they areA mutable class and a ladder of if/else. Make the type immutable and the decision one expression.Beginner · 18 min · Pro
  6. Catching what you can handleAn empty catch (Exception) and a leaked file handle. Handle the failure you know.Beginner · 16 min · Pro

Code Someone Else Can Change, in C#

The same two refactors as the JavaScript sprint, where the type system gives you more to work with and more to get wrong.

  1. Five levels deep, and the transfer is at the bottomA payout service where the one line that moves money is indented five times. Flatten it — and decide, while you are there, which of these five conditions is a bug and which is a business outcome.Beginner · 15 min
  2. The gateway’s JSON, parsed in the business logicA subscription service reaches into a payment provider’s JSON — txn_st_v3, ch_ident_key, resp_cd — and decides business outcomes from it. Put an adapter and a domain model between them so swapping provider is a new class, not a rewrite.Intermediate · 20 min · Pro

API Integration Sprint

Wire up Paystack the way a production checkout actually does it.

  1. Payment API IntegrationIntegrate the Paystack API to initialise a payment and surface the authorization URL.Beginner · 15 min
  2. The reference you were handedThe browser says the customer paid ₦150,000. Find out whether they did.Intermediate · 20 min

ASP.NET Core Refactor

Three pieces of working, wrong backend code. Fix what is wrong with them.

  1. Auth APIJWT with roles, a refresh endpoint, and passwords that are never stored in plain text.Intermediate · 25 min
  2. CRUD + PaginationA Products API that pages properly and never pulls the whole table into memory.Intermediate · 20 min · Pro
  3. AI Streaming EndpointProxy Claude and stream tokens to the browser as they arrive, not after the whole answer lands.Advanced · 25 min · Pro
  4. Vertical Slice RefactorA 90-line God Method doing validation, data access and payment in one controller. Make it a slice.Intermediate · 30 min · Pro
  5. Domain Model Security GuardA Payment whose state anyone can change, twice, without recording a transaction id. Close the door.Intermediate · 20 min · Pro
  6. Verifying What The Browser ClaimsAn endpoint that marks an order paid because the browser said so.Intermediate · 25 min · Pro
  7. Payment Webhook State MachineA public URL that trusts anything POSTed to it, holds the gateway open for three seconds, and hardcodes its secret.Advanced · 45 min · Pro

Persistence with EF Core

The Write Side teaches these in JavaScript with no ORM in the way. This is the same set, where you actually work.

  1. The query that ran four hundred timesA list endpoint that looks like one query and is four hundred. Fix it twice: once by projecting to exactly what the response needs, and once for the case where whole entities really are required.Intermediate · 20 min
  2. Tracking, and when not toSomebody read that AsNoTracking is faster and put it everywhere, including on the method that saves. Decide per path: reads do not track, writes must, and the report that reaches the same row twice needs the identity map without the snapshots.Intermediate · 20 min · Pro
  3. The migration that lost a columnThe scaffolder saw a renamed property and generated a drop and an add. It would have passed review and deleted every customer name in production. Rewrite it so the data survives, and so adding a required column works on a table that already has rows.Advanced · 20 min · Pro
  4. Where the transaction endsAn order, an outbox message and a ledger entry, written by two SaveChanges calls with a crash-shaped gap between them. Decide where the unit of work actually ends and make the gap impossible.Advanced · 20 min · Pro
  5. The concurrency tokenTwo people reserve the last unit of stock within a second of each other and both succeed. Give the row a version, let the second write fail, and turn that failure into something the caller can act on.Advanced · 20 min · Pro

Layered Architecture and Modular Systems

The other side of the argument the vertical-slice sprint makes — practised where it is enforced.

  1. Where Code LivesSeven files, seven projects, and one rule that does most of the work: the DTO layer must not be able to see an entity. Place each file where the dependency graph allows it.Intermediate · 20 min · Pro
  2. The Aggregate BoundaryAn order with lines. Decide what is a root, what is inside it, and what rule belongs to neither — then make it impossible to reach a line without going through the order.Advanced · 25 min · Pro
  3. The Application BoundaryThe layer everyone gets wrong. It orchestrates and authorises; it does not decide. Two kinds of validation live in two different places and both are needed.Intermediate · 20 min · Pro
  4. Modules and Shared ResourcesThe module graph is where the layering stops being a convention and becomes a rule. Wire it, and give every layer one shared vocabulary that ships inside the assembly.Advanced · 25 min · Pro
  5. Splitting the MonolithOrdering and Billing become separate services. The interesting question is not how to host two things — it is what they are allowed to know about each other.Advanced · 25 min · Pro
  6. The Frontend, Split To MatchOne Angular shell, one lazily-loaded package per backend service, and generated proxies so a backend rename breaks the build instead of production.Advanced · 25 min · Pro

Testing an ASP.NET Core API

xUnit, Moq and WebApplicationFactory — the suite that catches a regression before your users do.

  1. Your first xUnit testA [Fact], a name that says what it checks, and an assertion that can fail.Beginner · 12 min
  2. Five tests, one behaviourCopy-pasted [Fact]s with one number changed. Collapse them into a [Theory].Beginner · 12 min
  3. Stop calling the real thingA test that hits a real database and a real mail server. Replace both, and assert on the calls.Intermediate · 18 min · Pro
  4. The whole pipeline, in memoryRouting, model binding, filters and serialisation. Test the endpoint, not the controller method.Intermediate · 20 min · Pro
  5. The paths nobody tests404, 401, 409 and the shape of the error body. The half of the API that only shows up in production.Intermediate · 18 min · Pro
  6. The suite that only fails on CIShared state, a static context and a blocking .Result. Make every test independent.Advanced · 22 min · Pro

Resources and Concurrency

Handles that are never released, handlers that are never unsubscribed, and locks anyone can take.

  1. Giving the handle backA file handle held for the life of the process. Implement the pattern properly.Beginner · 15 min
  2. The leak you can readAn event handler nobody unsubscribes, and a static cache that only grows.Beginner · 15 min
  3. What you lock onlock(this), lock(typeof(T)) and lock("key"). Three ways to let a stranger deadlock you.Intermediate · 15 min · Pro
  4. The permit you never gave backA throttle that stops throttling, then stops working entirely.Intermediate · 18 min · Pro
  5. The app that stops answeringSync over async in a request path. It works in testing and dies under load.Intermediate · 18 min · Pro
  6. A deadline and a request to stopOne unresponsive host holds the whole import open. A token is accepted and ignored.Advanced · 20 min · Pro
  7. The scoped thing inside the singletonA background worker takes a DbContext in its constructor and holds it for the life of the process. It works in development, survives review, and fails under load as one connection is shared by everything. Resolve the scope where the work happens instead.Advanced · 20 min · Pro