cswork / libraryOpen practice workspace

Interview guides · Futures First

Futures First Software Engineer Interview Guide

Futures First Software Engineer interview guide: reported rounds, questions and how candidates describe the process.

The 60-second brief

At Futures First, a Software Engineer does not just write code; they build and optimize the high-performance infrastructure that powers real-time financial market analysis and execution. Operating in the fast-paced domain of global derivative markets, the technology team is responsible for developing low-latency data feeds, automated trading tools, and robust risk management systems. Every millisecond counts, making software efficiency, system reliability, and analytical precision the core drivers of business success. The role demands a unique combination of exceptional quantitative aptitude and solid software engineering fundamentals. You will work on complex, data-heavy systems where you must translate mathematical, statistical, and logical concepts into clean, high-performance code.

This guide is scoped to a Software Engineer candidate at Futures First.

Focus areas

  • Aptitude Testing
  • Stress Interview / Pressure Handling
  • Speed Under Time Constraints

The Futures First interview process

Futures First candidates report 3 rounds over 3-5 weeks. The stages below are what candidates describe, not a published process.

Online Screening Test

An intense test with strict time limits per question, negative marking, and a progressive format to filter candidates based on speed and reasoning.

What to demonstrate

  • An intense test with strict time limits per question, negative marking, and a progressive format to filter candidates based on speed and reasoning
  • Depth in Aptitude Testing

How to prepare

  • Answer aloud and timed: Calculate the product of 87 and 93 mentally in under 15 seconds.
  • Answer aloud and timed: Solve a series of 2-digit and 3-digit multiplication problems within a 30-second-per-question limit.

Technical Evaluations

Candidates may complete a take-home coding and mathematics assignment or participate in direct technical interviews focusing on core concepts.

What to demonstrate

  • Candidates may complete a take-home coding and mathematics assignment or participate in direct technical interviews focusing on core concepts
  • Depth in Aptitude Testing

How to prepare

  • Answer aloud and timed: Complete a complex numerical sequence puzzle: What is the next number in the sequence: 2, 9, 28, 65,...?
  • Answer aloud and timed: Answer memory-recall questions based on a complex geometric figure shown to you three questions prior.

Final Panel Interview

A comprehensive interview that includes technical defense of assignments, project deep-dives, and a behavioral stress test to assess adaptability and resilience.

What to demonstrate

  • A comprehensive interview that includes technical defense of assignments, project deep-dives, and a behavioral stress test to assess adaptability and resilience
  • Depth in Aptitude Testing

How to prepare

  • Answer aloud and timed: How many questions did you answer correctly in the previous speed math section, and what was your estimated accuracy percentage?
  • Answer aloud and timed: Given an array of integers, find the contiguous subarray with the largest sum (Kadane's Algorithm).

Where candidates lose points

Master Your Pace

In the online screening test, do not linger on a single difficult question. Because the test is progressive and highly time-constrained, lingering will cost you precious seconds that could be used to answer multiple easier questions. Learn to make rapid, calculated guesses or skips when necessary.

Over-Communicate Your Logic

During technical and puzzle-based rounds, never solve in silence. Talk your interviewer through your thought process, even if you are unsure of the final answer. They highly value structured thinking and want to see how you dissect a problem under pressure.

Check-then-act on shared state

Read, decide, write is not safe under concurrency unless the decision and the write are one atomic step: a unique constraint with conflict handling, a compare-and-set, or a row lock held for the whole transaction. Two requests can both pass the existence check before either inserts, which shows up as duplicate rows under load and never in a single-threaded test.

Questions & practice

Answer memory-recall questions based on a complex geometric figure shown to you three questions prior.

Medium · Speed Math & Aptitude

Approach

  1. Say what the runtime actually does before reasoning about the code.
  2. Name what is shared across threads and what owns each piece of state.
  3. Identify the window where an invariant is briefly untrue.
  4. Distinguish a value from a reference to it, and say which one you handed out.

Follow-up

  • What happens if two callers reach this at the same time?
  • Where could this allocate more than you expect?

Given an array of integers, find the contiguous subarray with the largest sum (Kadane's Algorithm).

Medium · Coding & Computer Science Fundamentals

Approach

  1. Restate the input: its shape, its size, and what is guaranteed about it.
  2. Name the brute-force solution and its complexity before improving on it.
  3. Choose the data structure from the access pattern, not from familiarity.
  4. State the target complexity and say which constraint rules the naive version out.

Follow-up

  • How does this change if the input no longer fits in memory?
  • What is the worst case, and how likely is it on real data?

Explain the difference between deep copying and shallow copying in Python, and write a code snippet demonstrat

Medium · Coding & Computer Science Fundamentals

Explain the difference between deep copying and shallow copying in Python, and write a code snippet demonstrating both.

Approach

  1. Restate the input: its shape, its size, and what is guaranteed about it.
  2. Name the brute-force solution and its complexity before improving on it.
  3. Choose the data structure from the access pattern, not from familiarity.
  4. State the target complexity and say which constraint rules the naive version out.

Follow-up

  • How does this change if the input no longer fits in memory?
  • What is the worst case, and how likely is it on real data?

How does Python manage memory internally, and what is the role of the garbage collector and reference counting

Medium · Coding & Computer Science Fundamentals

How does Python manage memory internally, and what is the role of the garbage collector and reference counting?

Approach

  1. Say what the runtime actually does before reasoning about the code.
  2. Name what is shared across threads and what owns each piece of state.
  3. Identify the window where an invariant is briefly untrue.
  4. Distinguish a value from a reference to it, and say which one you handed out.

Follow-up

  • What happens if two callers reach this at the same time?
  • Where could this allocate more than you expect?

Explain the concept of polymorphism in Object-Oriented Programming (OOP) with a real-world coding example.

Medium · Coding & Computer Science Fundamentals

Approach

  1. Restate the input: its shape, its size, and what is guaranteed about it.
  2. Name the brute-force solution and its complexity before improving on it.
  3. Choose the data structure from the access pattern, not from familiarity.
  4. State the target complexity and say which constraint rules the naive version out.

Follow-up

  • How does this change if the input no longer fits in memory?
  • What is the worst case, and how likely is it on real data?

Predict the exact output of a nested loop code block featuring variable shadowing and post-increment operators

Medium · Coding & Computer Science Fundamentals

Predict the exact output of a nested loop code block featuring variable shadowing and post-increment operators.

Approach

  1. Say what the runtime actually does before reasoning about the code.
  2. Name what is shared across threads and what owns each piece of state.
  3. Identify the window where an invariant is briefly untrue.
  4. Distinguish a value from a reference to it, and say which one you handed out.

Follow-up

  • What happens if two callers reach this at the same time?
  • Where could this allocate more than you expect?

Write the update path that detects a concurrent edit

Medium · optimistic concurrency · transactional outbox · audit history

resource carries version INT NOT NULL DEFAULT 1. resource_revision holds revision_id, resource_id, version, actor_user_id, change_kind, patch JSONB, request_id, created_at with UNIQUE (resource_id, version). outbox_event holds aggregate_type, aggregate_id, aggregate_version, event_type, payload, status. A PUT carries the version the client read. Write the exact statements for the single transaction that applies the edit, records the revision and enqueues 'resource.updated', and give the handler's branch on zero affected rows. Then say what PostgreSQL 16 does under READ COMMITTED when two of these updates hit one row at once.

Approach

  1. One transaction, three writes, no network call inside it: UPDATE resource SET title = $3, version = version + 1, updated_at = now() WHERE resource_id = $1 AND tenant_id = $4 AND version = $2; then INSERT the resource_revision row at version $2 + 1; then INSERT the outbox_event row at the same aggregate_version. The event goes to a table rather than a broker because no transaction spans both.
  2. Branch on the affected-row count before doing anything else. Zero has three causes — stale version, wrong tenant, row gone — so re-read once and map to 409 carrying the current version, or 404 for an id outside the caller's tenant, which also stops the endpoint confirming that another tenant's id exists.
  3. State the engine behaviour instead of assuming it. Under READ COMMITTED the second UPDATE blocks on the row lock, and when the first commits PostgreSQL re-evaluates the WHERE clause against the newly committed row, so the version predicate now fails and the statement reports zero rows. Under REPEATABLE READ the identical collision raises SQLSTATE 40001 instead, so the handler must fold both shapes into one conflict response.
  4. Keep UNIQUE (resource_id, version) even though the predicate already serialises writers. It is what makes a lost update unwritable if any other path ever reaches the revision table, and it converts a logic bug into 23505 rather than into a silently missing history row.

Follow-up

  • A client sends the version it read ten minutes ago and the resource has moved three versions. What is in your 409 so it can resolve the conflict without a full re-fetch?
  • Two editors, two disjoint fields, no overlap. Does your answer still refuse the second write, and should it?

Hold a per-tenant active cap against concurrent creates

Hard · write skew · isolation levels · constraints

A tenant on the standard plan may hold at most 50 resources with status='active'. The create handler runs SELECT count(*) FROM resource WHERE tenant_id = $1 AND status = 'active', compares to 50, then inserts. Two creates arrive 3 ms apart on different instances and the tenant lands at 51. Name the anomaly, say whether PostgreSQL 16 READ COMMITTED or REPEATABLE READ prevents it and why, then give an implementation that holds the cap at READ COMMITTED with the exact statements. Finally, say what changes when the cap is 'at most one running export per tenant' on job_run.

Approach

  1. Name it: write skew. The two transactions read an overlapping set and write disjoint rows, so there is no row-level conflict for the engine to detect and each commit is individually legal.
  2. Rule out the levels precisely. READ COMMITTED takes a fresh snapshot per statement and takes no lock on the counted rows, so both see 49. PostgreSQL's REPEATABLE READ is snapshot isolation: it removes non-repeatable reads and phantoms within the snapshot but still admits write skew, because the anomaly is not a re-read of a changed row, it is a read of a set that a concurrent transaction invalidates. Only SERIALIZABLE closes it, by tracking the read dependency and aborting one transaction with SQLSTATE 40001 — a guarantee that exists only if the application re-runs the whole transaction from the read.
  3. Convert the set predicate into a single-row conflict: keep tenant.active_resource_count and run UPDATE tenant SET active_resource_count = active_resource_count + 1 WHERE tenant_id = $1 AND active_resource_count < 50 in the same transaction as the INSERT. Zero affected rows is the cap, returned as 409. The row lock serialises the decision at any isolation level, and contention is bounded to one tenant's row — which is also the fair-scheduling unit, unlike a global counter that would convoy every tenant behind one row.
  4. State the cost you just took on: a counter is a second source of truth that can drift, so every path that changes status must adjust it inside the same transaction, and a periodic reconciliation has to exist, with resource_revision as the authority for what the count should have been.

Follow-up

  • A resource moves from archived back to active. Which statements change, and what breaks if the counter update and the status change land in different transactions?
  • The cap becomes plan-dependent and a plan can change mid-month. Where does the number 50 live, and who reads it?

Calculate the product of 87 and 93 mentally in under 15 seconds.

Medium · Speed Math & Aptitude

Approach

  1. Clarify what is being asked and what a complete answer contains.
  2. State your assumptions explicitly before working the problem.
  3. Say what you would check first and why it is the highest-information step.
  4. Work from the requirement backwards to the design.

Follow-up

  • What assumption would you test first?
  • How would you know your answer was wrong?

Solve a series of 2-digit and 3-digit multiplication problems within a 30-second-per-question limit.

Medium · Speed Math & Aptitude

Approach

  1. Clarify what is being asked and what a complete answer contains.
  2. State your assumptions explicitly before working the problem.
  3. Say what you would check first and why it is the highest-information step.
  4. Work from the requirement backwards to the design.

Follow-up

  • What assumption would you test first?
  • How would you know your answer was wrong?

Complete a complex numerical sequence puzzle: What is the next number in the sequence: 2, 9, 28, 65,...?

Medium · Speed Math & Aptitude

Approach

  1. Clarify what is being asked and what a complete answer contains.
  2. State your assumptions explicitly before working the problem.
  3. Say what you would check first and why it is the highest-information step.
  4. Work from the requirement backwards to the design.

Follow-up

  • What assumption would you test first?
  • How would you know your answer was wrong?

How many questions did you answer correctly in the previous speed math section, and what was your estimated ac

Medium · Speed Math & Aptitude

How many questions did you answer correctly in the previous speed math section, and what was your estimated accuracy percentage?

Approach

  1. Clarify what is being asked and what a complete answer contains.
  2. State your assumptions explicitly before working the problem.
  3. Say what you would check first and why it is the highest-information step.
  4. Work from the requirement backwards to the design.

Follow-up

  • What assumption would you test first?
  • How would you know your answer was wrong?

You are given two light bulbs and a 100-story building. Find the minimum number of drops required to determine

Medium · Probability, Statistics & Puzzles

You are given two light bulbs and a 100-story building. Find the minimum number of drops required to determine the highest floor from which a bulb can be dropped without breaking.

Approach

  1. Clarify what is being asked and what a complete answer contains.
  2. State your assumptions explicitly before working the problem.
  3. Say what you would check first and why it is the highest-information step.
  4. Work from the requirement backwards to the design.

Follow-up

  • What assumption would you test first?
  • How would you know your answer was wrong?

What is the probability of getting at least one head when flipping a biased coin three times, given the probab

Medium · Probability, Statistics & Puzzles

What is the probability of getting at least one head when flipping a biased coin three times, given the probability of a head is 0.6?

Approach

  1. Clarify what is being asked and what a complete answer contains.
  2. State your assumptions explicitly before working the problem.
  3. Say what you would check first and why it is the highest-information step.
  4. Work from the requirement backwards to the design.

Follow-up

  • What assumption would you test first?
  • How would you know your answer was wrong?

Explain your step-by-step mathematical approach to solving a multi-variable optimization problem from your tak

Medium · Probability, Statistics & Puzzles

Explain your step-by-step mathematical approach to solving a multi-variable optimization problem from your take-home technical assignment.

Approach

  1. Clarify what is being asked and what a complete answer contains.
  2. State your assumptions explicitly before working the problem.
  3. Say what you would check first and why it is the highest-information step.
  4. Work from the requirement backwards to the design.

Follow-up

  • What assumption would you test first?
  • How would you know your answer was wrong?

Three cards are in a bag: one is red on both sides, one is black on both sides, and one is red on one side and

Medium · Probability, Statistics & Puzzles

Three cards are in a bag: one is red on both sides, one is black on both sides, and one is red on one side and black on the other. You pull a card and see a red side. What is the probability that the other side is also red?

Approach

  1. Clarify what is being asked and what a complete answer contains.
  2. State your assumptions explicitly before working the problem.
  3. Say what you would check first and why it is the highest-information step.
  4. Work from the requirement backwards to the design.

Follow-up

  • What assumption would you test first?
  • How would you know your answer was wrong?

One customer endpoint stalls deliveries to every other destination

Medium · bulkhead · timeouts · saturation

The egress service delivers about 1.5k webhooks/second across 40,000 destinations, with a per-destination concurrency cap of 4 and a 10-second connect-plus-read timeout. Throughput falls to 300/second, queue depth climbs, and p99 delivery latency for unaffected destinations goes from 200 ms to minutes, while the error rate barely moves. One tenant holds 900 destination rows whose URLs share a hostname that now answers in 9.5 seconds. Explain the mechanism with the arithmetic, then give the containment in the order you would apply it.

Approach

  1. Look at saturation before errors. A flat error rate with collapsing throughput says nothing is failing, things are waiting, so the first signal to pull is in-flight request count or pool wait time rather than the error counter. This is the distinction that decides the whole investigation.
  2. Group in-flight work by resolved host, not by destination id. The cap is keyed per destination row, so 900 rows sharing one hostname buy 3,600 concurrent slots against a single host, each held for 9.5 seconds. The bulkhead was never a bulkhead for that host, and grouping by the wrong dimension is why the dashboard looked healthy.
  3. Do the arithmetic in both directions. Required concurrency is arrival rate times latency, so 1.5k/second at 200 ms needs about 300 in flight, which is entirely consumed by 3,600 slow slots; conversely whatever concurrency is left sustains rate equals concurrency divided by 9.5 seconds, which is the 300/second you are seeing. Matching both numbers is what promotes this from a plausible story to the mechanism.
  4. Explain why the circuit breaker never helped. It opens on consecutive failures, and a 9.5-second response inside a 10-second timeout is a success. Slow is not failing, so an error-rate breaker cannot see this; you need a slow-call ratio, a deadline propagated from the caller's remaining budget, or a concurrency limiter.

Follow-up

  • The host recovers to 80 ms. How long does the queue take to drain, and what does the drain do to the recovered host?
  • Where should the 10-second timeout number actually come from?

Suggested practice checklist

Built from the rounds and topics Futures First candidates report.

Day 1 — Map the Futures First loop

  • Write out the reported sequence: Online Screening Test, Technical Evaluations, Final Panel Interview.
  • For each round, write one sentence on what it is judging, from the description above, and mark the one you are least ready for.

Deliverable: A one-page map of the 3 reported rounds, with the weakest marked.

Day 2 — Work Aptitude Testing

  • Spend the session on Aptitude Testing, which Futures First candidates report being tested on.
  • Write one worked example in Aptitude Testing and time yourself on it.

Deliverable: One timed worked example in Aptitude Testing.

Day 3 — Work Stress Interview / Pressure Handling

  • Spend the session on Stress Interview / Pressure Handling, which Futures First candidates report being tested on.
  • Write one worked example in Stress Interview / Pressure Handling and time yourself on it.

Deliverable: One timed worked example in Stress Interview / Pressure Handling.

Day 4 — Work Speed Under Time Constraints

  • Spend the session on Speed Under Time Constraints, which Futures First candidates report being tested on.
  • Write one worked example in Speed Under Time Constraints and time yourself on it.

Deliverable: One timed worked example in Speed Under Time Constraints.

Day 5 — Answer out loud: Speed Math & Aptitude

  • Answer aloud, timed: Calculate the product of 87 and 93 mentally in under 15 seconds.
  • Answer aloud, timed: Solve a series of 2-digit and 3-digit multiplication problems within a 30-second-per-question limit.

Deliverable: Spoken answers to 2 reported Speed Math & Aptitude question(s), under time.

Day 6 — Answer out loud: Coding & Computer Science Fundamentals

  • Answer aloud, timed: Given an array of integers, find the contiguous subarray with the largest sum (Kadane's Algorithm).
  • Answer aloud, timed: Explain the difference between deep copying and shallow copying in Python, and write a code snippet demonstrating both.

Deliverable: Spoken answers to 2 reported Coding & Computer Science Fundamentals question(s), under time.

Day 7 — Answer out loud: Probability, Statistics & Puzzles

  • Answer aloud, timed: You are given two light bulbs and a 100-story building. Find the minimum number of drops required to determine the highest floor from which a bulb can be dropped without breaking.
  • Answer aloud, timed: What is the probability of getting at least one head when flipping a biased coin three times, given the probability of a head is 0.6?

Deliverable: Spoken answers to 2 reported Probability, Statistics & Puzzles question(s), under time.

Behavioural preparation

Behavioural rounds judge the decision you made and what it cost.

Estimate work you have never done and defend the range

Hard · estimation · backfills · expand-contract

You are asked to estimate a change you have never attempted: add a column to a 100-million-row table, populate it, move reads across, and drop the old shape. Give a range with the assumptions that generate it, including batch size, the signal your backfill throttles on, and wall-clock hours, and name the three unknowns that would move the number most. Then describe a real estimate you gave under comparable ignorance: how you expressed its uncertainty, what you committed to, and how wrong you turned out to be.

Approach

  1. Decompose into independently deployable steps before estimating anything: add the column nullable, write both shapes, backfill in batches, verify, move reads, stop writing the old shape, drop it. That is four deploys spread over days, and the calendar estimate is dominated by them rather than by the loop's runtime.
  2. Do the arithmetic aloud for the part that has arithmetic in it: batch size times number of batches times per-batch duration, at a write rate the primary can absorb alongside roughly 1.2k writes per second of production traffic. The loop is throttled by replication lag and lock waits, not by how fast it can issue statements.
  3. Price the schema step by its lock rather than its statement duration. In PostgreSQL an ALTER TABLE taking ACCESS EXCLUSIVE waits for every open transaction on that table while later queries queue behind it, so a millisecond change issued during a thirty-second analytics query stalls that table for thirty seconds. Adding a nullable column with a non-volatile default avoids a rewrite from version 11; a new index wants CREATE INDEX CONCURRENTLY, which cannot run inside a transaction block and leaves an invalid index behind if it fails.
  4. Express the answer as a range whose endpoints each trace to a stated assumption, then name the cheapest experiment that collapses it, which is almost always running one real batch against the real table and multiplying.

Follow-up

  • How do you verify the backfill genuinely finished, given rows written by production traffic while it ran?
  • Where does the backfill resume from after a worker is killed mid-batch, and what makes that resume point trustworthy?

Unblock an engineer without taking the keyboard

Easy · mentoring · leases · at-least-once

A teammate has spent two days on a job handler that occasionally writes duplicate rows. They are certain the queue is delivering twice by mistake. You suspect a lease expiring under a slow handler, so the job is running concurrently with itself. Describe how you have unblocked someone in this position: what you asked before offering a hypothesis, what you showed them rather than told them, and what you left them owning. Then say what you would do if their theory turned out to be the right one.

Approach

  1. Ask before diagnosing, and ask for things answerable from data they already have: the attempt count on the job rows that produced duplicates, the handler's observed duration against its lease expiry, and whether the duplicate rows share a natural key that a unique constraint could have caught.
  2. Teach the shape rather than the answer. A lease cannot distinguish a dead worker from a slow one, so a handler that outruns its lease is running twice by design, and deploys deliver the other half by killing handlers mid-run on every rollout. Both of their candidate theories produce identical duplicate rows, which is why the evidence has to come from timings rather than from argument.
  3. Hand over a checklist they execute: a natural key on every write the handler performs so the second copy collides rather than appends, the record of intent written before any external effect, a lease heartbeat while running, and the metric that shows it working.
  4. Keep ownership with them deliberately. Pair on the first write, then step back; if you finish it yourself you have closed one ticket and left the same person stuck on the next redelivery.

Follow-up

  • How would you distinguish a genuine double-delivery from a lease expiry using only the data already stored?
  • Their handler calls an external endpoint before recording that it did. What do you tell them to change first?

Narrate an outage you owned from page to postmortem

Hard · incident response · blast radius · postmortems

Pick an incident you personally drove, ideally one where writes were affected rather than reads. In six to eight minutes: state the symptom as it first appeared on a dashboard, the blast radius you established before you knew the cause, the mitigation you applied and when, the mechanism you eventually proved, and the follow-up that would prevent a repeat. Bring numbers: error rate, tenants affected, minutes to mitigate, minutes to resolve. If you cannot name what you measured, choose a different incident.

Approach

  1. Open on the signal rather than the cause: which metric at which percentile moved, on which service, at what time, so the listener follows the same evidence you had rather than a conclusion you already reached.
  2. Separate mitigation from diagnosis out loud. State what you did to stop the bleeding (flag off, shed traffic, drain a lease, roll back a deploy) and say plainly that you did it before the mechanism was known, because those are two jobs with different deadlines.
  3. Establish blast radius in countable terms: how many tenants, how many writes, and crucially whether the effect was loss or only delay. An append-only revision table or a pending outbox row means the change survived and the projection was merely behind, which is a repair rather than a data-loss incident.
  4. Prove the mechanism instead of asserting it. Name the trace span that grew, the plan that flipped to a sequential scan, the lease that expired, plus one alternative you ruled out and the signal that stayed flat while you ruled it out.

Follow-up

  • What would you do differently in the first five minutes, given the same dashboard and no more information?
  • Which follow-up action did you deliberately not take, and why was dropping it the right call?