Practical coding round

What this round tests

The two coding questions in our bank that were reported from FDE interviews are practical: call a REST API and use the result, and validate a form and append the rows to a table. The other reported questions on this page's list are similar work from engineering loops at FDE-hiring companies: query an endpoint and combine the results, parse logs or CSVs into a report, crawl linked resources, or find the bug in a small service. Two of them drop you into an existing multi-file codebase rather than a blank editor.

• Getting to running code fast, then improving it, rather than designing in your head for 20 minutes.
• Reading a data or API contract carefully: field types, nullability, pagination, error codes, units and time zones.
• Handling the edge cases real data has: duplicates, out-of-order records, malformed rows, partial failures, money and dates.
• Structure: small functions for fetch, parse, transform and output, so a follow-up ("now add caching", "now make it resumable") is a small change.
• Debugging code you did not write: reproduce, isolate, fix, and protect the fix with a test.

How to approach it: read, probe, skeleton, happy path, harden, verify

Our guidance (editorial), not a candidate report

1. 1. Read the contract

   Write down the input shape and the expected output in a comment before coding: field names, types, which fields can be missing, and what the API does at the end of the data. Ask about anything the sample does not settle (are amounts strings or numbers? which time zone are dates in?).

2. 2. Probe the data

   Print three records, the count, and the distinct values of any status field. Look for nulls, duplicates and mixed formats. Two minutes here saves twenty later.

3. 3. Skeleton

   Write function signatures for fetch, parse, transform and report, with a main that wires them. Interviewers can follow the plan even before the bodies exist.

4. 4. Happy path end to end

   Make the smallest input produce the right output, and run it. Running code at minute 15 is worth more than perfect code at minute 40.

5. 5. Harden

   Add pagination termination, retries with backoff for 429 and 5xx (honouring Retry-After), timeouts, deduplication by key, exact decimal money, time-zone aware dates, and a place for bad rows (count and keep them with a reason instead of crashing or silently dropping).

6. 6. Verify and talk scale

   Assert on a case you computed by hand, add one test per edge case you handled, then say what changes at 100 times the data: streaming instead of loading everything, checkpointing the cursor, concurrency limits.

Worked example: revenue per customer from a paginated orders API

import random
import time
from collections import defaultdict
from datetime import datetime, timedelta, timezone
from decimal import Decimal

import requests

ORDERS_URL = "https://api.example.com/v1/orders"
RETRYABLE = {429, 500, 502, 503, 504}


def get_with_retries(session, url, params, max_retries=5):
    """GET with backoff. Retries timeouts, 429 and 5xx; any other 4xx is a bug in our request."""
    for attempt in range(max_retries + 1):
        try:
            resp = session.get(url, params=params, timeout=10)
        except (requests.ConnectionError, requests.Timeout):
            resp = None
        if resp is not None and resp.status_code not in RETRYABLE:
            resp.raise_for_status()
            return resp
        if attempt == max_retries:
            break
        if resp is not None and resp.status_code == 429 and resp.headers.get("Retry-After", "").isdigit():
            wait = int(resp.headers["Retry-After"])
        else:
            wait = min(30, 2 ** attempt) * random.uniform(0.5, 1.0)  # exponential backoff with jitter
        time.sleep(wait)
    status = resp.status_code if resp is not None else "network error"
    raise RuntimeError(f"giving up on {url} after {max_retries} retries ({status})")


def fetch_orders(session, updated_since):
    """Yield every order updated since the given time, following the cursor to the end."""
    params = {"updated_since": updated_since.isoformat(), "limit": 200}
    while True:
        body = get_with_retries(session, ORDERS_URL, params).json()
        yield from body["data"]
        cursor = body.get("next_cursor")
        if not cursor:
            return
        params = {"cursor": cursor, "limit": 200}

def parse_ts(s):
    # fromisoformat only accepts a trailing "Z" from Python 3.11 on.
    return datetime.fromisoformat(s.replace("Z", "+00:00"))


def net_revenue_by_customer(orders, fx_to_usd, now, days=30):
    cutoff = now - timedelta(days=days)

    latest = {}  # order id -> newest copy seen
    for o in orders:
        prev = latest.get(o["id"])
        if prev is None or parse_ts(o["updated_at"]) > parse_ts(prev["updated_at"]):
            latest[o["id"]] = o

    totals = defaultdict(Decimal)
    for o in latest.values():
        created = parse_ts(o["created_at"])
        if not (cutoff <= created < now) or o["status"] in ("cancelled", "refunded"):
            continue
        if o["currency"] not in fx_to_usd:
            raise ValueError(f"no exchange rate for {o['currency']} (order {o['id']})")
        net = Decimal(o["amount"]) - Decimal(o.get("refunded_amount") or "0")
        totals[o["customer_id"]] += net * fx_to_usd[o["currency"]]

    return {c: v.quantize(Decimal("0.01")) for c, v in totals.items()}


def main(session, fx_to_usd):
    now = datetime.now(timezone.utc)
    orders = fetch_orders(session, updated_since=now - timedelta(days=30))
    return net_revenue_by_customer(orders, fx_to_usd, now)

class FakeResp:
    def __init__(self, status, body=None, headers=None):
        self.status_code, self._body, self.headers = status, body, headers or {}

    def json(self):
        return self._body

    def raise_for_status(self):
        if self.status_code >= 400:
            raise requests.HTTPError(self.status_code)


class FakeSession:
    def __init__(self, responses):
        self.responses = list(responses)

    def get(self, url, params, timeout):
        return self.responses.pop(0)


def order(id, cust, amount, updated, status="paid", refunded="0.00", cur="USD"):
    return {"id": id, "customer_id": cust, "status": status, "amount": amount,
            "refunded_amount": refunded, "currency": cur,
            "created_at": "2026-11-01T10:00:00Z", "updated_at": updated}


def test_dedupes_refunds_and_retries(monkeypatch):
    monkeypatch.setattr(time, "sleep", lambda s: None)
    page1 = {"data": [order("o1", "c1", "100.00", "2026-11-01T10:00:00Z"),
                      order("o2", "c2", "50.00", "2026-11-01T10:00:00Z")],
             "next_cursor": "abc"}
    # o1 changed while we paged: it reappears with a partial refund.
    page2 = {"data": [order("o1", "c1", "100.00", "2026-11-02T09:00:00Z",
                            status="partially_refunded", refunded="30.00"),
                      order("o3", "c2", "20.00", "2026-11-01T11:00:00Z", status="refunded", refunded="20.00")],
             "next_cursor": None}
    session = FakeSession([FakeResp(429, headers={"Retry-After": "1"}),
                           FakeResp(200, page1), FakeResp(200, page2)])
    now = datetime(2026, 11, 10, tzinfo=timezone.utc)
    orders = fetch_orders(session, now - timedelta(days=30))
    assert net_revenue_by_customer(orders, {"USD": Decimal("1")}, now) == {
        "c1": Decimal("70.00"), "c2": Decimal("50.00")}

Common follow-ups and what they probe

"The job dies on page 400 of 900. What happens on rerun?"

Probes resumability. Checkpoint the cursor (and the partial aggregate, or recompute it from stored raw pages) after each page, and make reprocessing idempotent so a repeated page cannot double count.

"Would you retry a POST that creates a payment?"

Probes idempotency. Only with an idempotency key the server honours; otherwise a timeout followed by a retry can charge twice. Reads are safe to retry, writes need a key or a check-then-write.

"Ten workers share one API key with a limit of 50 requests per second."

Probes coordination. Independent backoff makes workers collide. Use a shared rate limiter (a token bucket in Redis, or a single fetcher feeding a queue) sized below the limit.

"How do you test this without hitting the real API?"

Probes design for testability. Inject the HTTP session (as above), record a few real responses as fixtures, and add contract tests that run against a sandbox on a schedule rather than on every commit.

"Ten percent of rows fail to parse. What do you do?"

Probes data-quality judgement. Do not drop them silently: count them, keep each with its reason, report the rate, and agree with the customer on a threshold that stops the run.

How it is scored

Our guidance (editorial), not a candidate report

Our synthesis of what interviewers in this round look for. Exact rubrics vary by company and are not published.

Common mistakes

• Using floats for money, then rounding at the end and getting a different total from the customer's finance team.
• Comparing naive and time-zone aware datetimes, or treating a UTC timestamp as a local business date.
• A pagination loop with no clear end condition, or one that skips the last page.
• Catching every exception and continuing, which turns a bug into silently wrong numbers.
• Retrying requests that are not safe to repeat.
• Loading every page into a list before processing when a generator would do.
• Building a class hierarchy before a single record has been parsed.

Practice questions for this round

Reported interview questions from our bank that fit this round, reviewed by hand. They come from user uploads and 1Point3Acres posts. They were reported from software, ML and AI engineering loops, many of them at companies that hire forward deployed engineers; only 6 on this list were reported from an FDE loop as such. Questions marked Free are open to everyone.

1. 1.Choose Checkout Coupons under a Loyalty-Point Budget to Maximize Savings

   4/5

   A coding question on deciding which store coupons to activate when each one costs loyalty points and only a fixed allowance of points is available per purchase. The aim is the largest total saving, where savings follow stacking rules, a per-line limit and cent rounding.

   Palantirreported September 2026
2. 2.Grocery Checkout Coupons with Category Stacking and a Discount Cap

   3/5

   A coding question on producing receipt totals for a shopping cart when percentage coupons can target single products or whole categories and can combine on the same line. Each line's saving is limited, and every amount has to come out exact to the cent.

   Palantirreported September 2026
3. 3.Most Squares Covering One Grid Cell

   3/5

   A coding question about square regions laid over a large map of cells: find how many regions stack up on the busiest cell, and in a follow-up report the count for every cell, with up to a hundred thousand regions on a thousand-by-thousand map.

   Googlereported August 2026
4. 4.REST API: Country Codes

   2/5

   In this practical API integration challenge reported at Palantir, you will write a routine that queries a remote directory service to retrieve and format telephone metadata. The task requires parsing incoming JSON payloads, handling empty or multi-result scenarios, and correctly concatenating international dialing prefixes according to strict specifications. It tests your proficiency in handling external web requests, data parsing, and string formatting. Access the complete programming task details and verified model solution with a subscription.

   Palantir
5. 5.Validate Form and Append to Table

   2/5

   Validate three form fields in the browser and add the accepted entry to a table, using no framework at all. This Amazon front-end question is about the parts a library usually hides: per-field rules, where error messages live, and how a new row is built and attached to the document. You will keep the validation rules separate from the rendering, surface the first failure clearly, and avoid rebuilding the whole table on each submission. A subscription unlocks the complete problem and the reference implementation.

   Amazon
6. 6.URL Maze — Recursive API Crawl to Congrats

   3/5

   This Ramp interview challenge features an automated web traversal puzzle where developers must recursively request data endpoints, parse JSON payloads, and navigate through a directed graph of links until reaching a target destination. The problem evaluates graph exploration techniques, cycle detection, recursive logic, and resilience against network anomalies or authentication hurdles. Candidates need to build a robust crawler that filters paths and returns the terminal node securely. To explore the full problem requirements and an ideal solution, a paid subscription is required.

   Rampreported October 2026
7. 7.Service Failure Forensics: Logs and Dependencies

   3/5

   Investigate complex system outages by analyzing sorted log files and dependency graphs in this multi-part Snowflake interview exercise. You will apply binary search techniques to pinpoint initial failure indicators and employ graph traversal strategies to map cascading service disruptions across a distributed architecture. This task thoroughly tests your diagnostic thinking and algorithmic efficiency. Access to the full problem text and complete model solution requires a subscription.

   Snowflakereported February 2026
8. 8.Process Logs

   2/5

   Parse a log of money transfers and report the accounts whose activity meets the stated threshold. This Snowflake question is string handling with a careful contract: identifiers are digit strings rather than numbers, a self-transfer counts once rather than twice, and the output order is specified. You will split each record safely, count per account, and sort the result the way the statement demands. A subscription unlocks the full problem and the reference solution.

   Snowflake
9. 9.Concurrent Web Crawler with Sorted CSV Export

   3/5

   A hands-on engineering question about building a robust concurrent program that gathers data from many web pages, orders the results and exports them. It checks how you handle shared state, failures and scale.

   Salesforcereported March 2026
10. 10.Flatten Nested JSON / HashMap to String

    3/5

    This technical coding challenge commonly seen at Salesforce examines your ability to manipulate hierarchical structures using recursion or iterative traversal. You are asked to transform a deeply nested associative structure into a single-level layout utilizing dot-separated keys for leaf elements. This tests your proficiency in handling diverse data types, managing recursive base cases, and restructuring complex information cleanly. Unlock the full problem details and optimal algorithmic solution with our comprehensive subscription.

    Salesforcereported January 2026
11. 11.Code Review of a Seeded Python Service

    3/5

    A code review exercise: read a small Python module that mixes SQL, configuration, request handling and a payment call, and write actionable comments on its defects. It tests breadth of review across security, concurrency, schema design and error handling.

    Salesforcereported March 2026
12. 12.Refactor Nested Conditionals into a Rule Table (TypeScript)

    3/5

    A coding question on cleaning up a TypeScript function whose behavior is spread over nested conditionals. It covers writing characterization tests, moving the variation into data, and explaining which design pattern suits the result.

    Salesforcereported February 2026
13. 13.Debug a Multi-File Project Assignment System (Fix Failing Tests)

    3/5

    This debugging task, reported from Scale AI interviews, drops candidates into a multi-file project assignment codebase with failing test cases. Developers must navigate a complex software structure involving numerous source files and structured data assets to isolate defects, interpret test failures, and apply correct patches. The assessment measures code comprehension, debugging methodology, and systematic problem-solving within unfamiliar environments. Examining the complete project setup, codebase context, and model solution requires a paid subscription.

    Scale AIreported July 2026
14. 14.Existing Codebase Debugging Round

    3/5

    In this Scale AI technical evaluation, candidates face a realistic codebase debugging exercise designed to test practical software engineering skills. Instead of building from scratch, you must quickly orient yourself within an unfamiliar multi-file project, execute existing test suites, isolate subtle defects, and fix them under time constraints. This scenario assesses your code navigation abilities and troubleshooting methodology. The full problem and model solution require a subscription.

    Scale AIreported May 2026
15. 15.Data Processing and Bug Fixing Task

    2/5

    Write a routine that totals a list of numbers, cover it with tests, and then extend it without breaking what already worked. This Rippling exercise is a working-habits probe rather than an algorithm question: the tests you volunteer, including the empty and negative cases, are most of the signal. You will keep the extension backward compatible and explain how your tests would have caught the regression. The full problem and the reference solution require a subscription.

    Rippling
16. 16.Multithreaded BankAccount Race-Condition Bug Hunt

    2/5

    This xAI coding challenge investigates concurrency vulnerabilities by presenting a flawed financial account implementation prone to classic multithreading hazards. Candidates must identify timing defects and demonstrate safe encapsulation patterns to prevent data corruption during simultaneous updates. Unlocking the complete troubleshooting guide and model code requires a subscription.

    xAIreported April 2026
17. 17.LLM-Oriented String Processing (Phone Screen)

    3/5

    Clean up a raw multi-line transcript and turn it into structured turns, applying a fixed sequence of text rules before any parsing happens. Reported in an Anthropic phone screen, this question rewards following the specification in the stated order, because reordering two of the cleanup steps changes the output. You will strip internal markers, normalise whitespace, drop blank lines, and decide what to do with a line that has no recognisable speaker. Subscribers can read the complete problem and the reference pipeline.

    Anthropic
18. 18.Convert Stack Samples to Trace Events

    Free3/5

    A coding question on profiler data. It checks that you can turn periodic snapshots of a program's call stack into timed events, keep recursive and differently-called frames apart, and smooth over brief gaps with a tolerance window while keeping exact interval boundaries. A discussion part compares two ways of matching frames between snapshots.

    Anthropicreported June 2026
19. 19.Text Highlighting / Citation Tagging

    3/5

    This string-processing challenge, regularly utilized in technical interviews at Harvey, focuses on identifying and formatting specific lexical segments within generated prose based on external reference collections. The problem tests your aptitude for interval merging, text parsing, and hash-based lookups while handling overlapping regions and ranking frequencies. Unlock the complete problem context and optimal code implementation by subscribing.

    Harveyreported July 2026
20. 20.Find the Incorrect Data Labeler

    3/5

    Audit a pile of crowd annotations to find the single worst human labeller, judged against the majority opinion on each item rather than against any ground truth. Reported at OpenAI, this exercise rewards clean aggregation in two passes and punishes anyone who forgets what happens when a vote ties. You will group annotations per item, resolve majorities, score each labeller by disagreement rate, and break ties deterministically. The full problem statement and the reference implementation are available with a subscription.

    OpenAI
21. 21.Work Queue with Task Dependencies (Leases, Retries, Dead-Letter)

    4/5

    Build a work queue that hands out tasks under a lease, retries the ones that fail, and refuses to release anything whose prerequisites have not finished. This OpenAI question combines dependency ordering with the bookkeeping of a real queue: reservation tokens, expiring leases, attempt budgets, and a dead-letter destination. You will decide when an expired lease returns work to the ready set, keep tokens from being replayed, and release dependents only on genuine success. The complete problem and reference implementation require a subscription.

    OpenAIreported October 2026
22. 22.REST API Integration and Aggregation

    Free3/5

    This practical integration challenge, frequently featured in interviews at Stripe, tests your ability to interact with external web services and manage data pipelines. You will write code to query an external endpoint, parse structured payloads, and compute specific summaries while handling real-world network concerns like pagination and resilience. Success relies on robust system plumbing and clean data transformation rather than abstract graph theory or complex searching techniques. To explore the complete problem description, architectural best practices, and a fully tested reference implementation, please subscribe today.

    Stripereported June 2026
23. 23.Finest Food Outlet (API pagination + filtering + tie-breaking)

    Free3/5

    This Blink Health interview question evaluates your ability to interact with paginated remote endpoints, apply conditional criteria, and manage data sorting rules effectively. You will need to systematically retrieve records across multiple pages, evaluate specific attributes against thresholds, and handle tie-breaking logic to isolate the best candidate. Access to the complete problem description and model solution requires a subscription.

    Blink Health
24. 24.User Access Log Storage and Time Range Query System

    3/5

    In this engaging Glean interview question, candidates are tasked with designing an efficient mechanism to store and retrieve historical user activity records. The challenge evaluates your capability to manage structured event data and implement rapid temporal lookups across custom intervals for specific accounts. You will need to balance memory utilization with query speed to handle varying log volumes effectively. To explore the full problem description and examine the complete expert implementation, a subscription is required.

    Glean
25. 25.Implement a Snowflake Query Client (Start Query & Get Query Status)

    3/5

    This Datadog backend question tests interface design for a remote query service: dependency injection for testability, bounded retries for transient failures, and a stable status schema. It also checks that you separate transport errors from query errors and keep status polling free of side effects.

    Datadogreported July 2026
26. 26.Pagination API Wrapper

    3/5

    Reported during Lyft interviews, this task requires building an abstraction layer over an immutable paginated data source to serve arbitrary chunk sizes smoothly across sequential calls. It tests your object-oriented design skills, internal state tracking, and boundary management for chunked data streams. The full problem statement, architectural guidelines, and complete reference solution require a subscription.

    Lyftreported November 2025
27. 27.Payment Reconciliation - Transaction Matching

    3/5

    This Stripe technical interview puzzle focuses on financial ledger reconciliation, requiring you to pair transaction records across two distinct systems while accounting for time windows and discrepancies. It evaluates your competency in designing robust matching algorithms, handling missing data fields, and categorizing various types of data mismatches. To review the full problem specification and reference implementation, a paid subscription is needed.

    Stripereported May 2026
28. 28.Debug a Payment Service That Double-Charges on Retry

    3/5

    A debugging round on a checkout handler that misbehaves when the network or the process fails at the wrong moment. You trace each failure to a concrete sequence of events, make client retries safe, and decide what to do about outcomes that are genuinely unknown at request time.

    Mercorreported October 2026

FAQ

Is FDE coding easier than a standard software engineering coding interview?

It is different rather than easier. Algorithmic depth matters less, but the bar on correctness with messy data, API behaviour and code quality is high, and the problems are longer and more open-ended.

Which language should I use?

Python is the most common choice because data handling and HTTP are short to write. Use the language you are fastest and most correct in, unless the company asks for a specific one.

Can I look things up during the interview?

It varies by company and round, and is not something our reports pin down. Ask at the start what is allowed. Even when documentation or an assistant is allowed, explain what you are checking and why.

Do I need to memorise LeetCode patterns?

Know the basics well (hash maps, sorting, heaps, BFS and DFS, intervals, sliding windows), because they show up inside practical problems. Grinding hundreds of puzzles is a poor use of time for this role.