Old Mission SWE Intern Interview 2027: Coding, C++, and Low-Latency Trading Systems

Old Mission's current 2027 Software Engineer internship points to a clear technical center: C++ trading applications, computer science fundamentals, and systems that support electronic markets. The role is not a finance trivia contest. Old Mission explicitly says no finance experience is required, but it does expect candidates to understand how reliable software supports fast-moving markets.

What Old Mission does not publish is one universal 2027 online assessment, provider, cutoff, or interview sequence. Prepare from the official role first, then treat candidate reports as possible formats rather than promises.

Quick answer: what should you prepare?

Prepare for three layers. First, solve coding problems cleanly under time pressure. Second, explain C++ behavior precisely, especially ownership, lifetime, containers, move semantics, and concurrency. Third, reason about a trading system as an event pipeline where correctness, predictable latency, recovery, and risk controls all matter.

Evidence level	What is currently supported	How to prepare
Official	Chicago internship, June 1 start, C++ trading applications, algorithms, data structures, systems, and collaboration with engineers and traders.	Make C++, coding, and systems your core plan.
Candidate-reported	Recent adjacent engineering reports mention an in-person test, low-level C++, DSA, Python analysis, and Linux work.	Practice the underlying skills, but do not assume the same sequence.
Not publicly fixed	OA platform, question count, cutoff, exact rounds, and response timeline.	Follow the instructions in your own invitation.

What Old Mission officially confirms for 2027

The current internship listing describes an in-office Chicago role supporting C++-based trading applications and tools. Interns receive hands-on projects, work directly with engineers and traders, and learn how electronic trading systems support the business.

The published qualifications are unusually specific. Candidates should be pursuing a bachelor's or master's degree in Computer Science, Computer Engineering, or a similar field; have at least junior standing; graduate in December 2027 or May 2028; hold at least a 3.0 GPA; and be able to start June 1, 2027. The posting asks for comfort with one or more of C++, Python, or TypeScript plus strong data structures, algorithms, and systems fundamentals.

Old Mission also says no finance experience is required. That is permission to spend most of your preparation time on engineering. Learn enough market vocabulary to frame your design choices, but do not replace coding and systems work with options theory or speed arithmetic unless your recruiter says the process includes it.

What is known about the interview process?

Old Mission does not currently publish a role-specific 2027 interview map. There is no official basis for promising that every intern receives a particular OA vendor, an identical number of questions, or the same onsite schedule. A recruiter email or assessment invitation is more authoritative than any public guide.

Recent candidate reports on Glassdoor provide useful but limited signals. An August 2026 Software Development Engineer candidate described an in-person test and detailed questions about low-level C++. A July 2026 Python Software Engineer candidate reported recruiter and engineer screens followed by DSA in Python, a Python analysis exercise, and a Linux challenge.

Those are adjacent roles, not a confirmed intern loop. A much older 2019 internship report mentioned a coding test, a lead-engineer phone call, a Chicago final round, and move semantics. Its only safe lesson is that coding and C++ depth have appeared before; the sequence is too old to treat as a 2027 forecast.

Coding preparation: solve the problem and defend the implementation

Review arrays, strings, hash maps, stacks, queues, heaps, trees, graphs, sorting, binary search, and basic dynamic programming. The goal is not to memorize a giant list. It is to move from an ambiguous prompt to a correct, testable implementation without losing track of input constraints.

For every problem, state the data model and invariant before coding. Then test empty input, one element, duplicates, overflow, invalid state, and the largest relevant size. Explain time and space complexity, but also mention practical costs such as repeated allocation, copying, or poor locality when they matter.

Trading firms often care about disciplined output and edge cases because a small state error can propagate quickly. Practice writing parsers and small stateful components, not only pure functions. If the prompt changes, update the invariant first, then the code and tests.

C++ topics that deserve focused review

Start with ownership and lifetime. Be able to explain stack versus dynamic storage, RAII, references, raw pointers, unique_ptr, shared_ptr, destructors, copy operations, move operations, and when an object becomes invalid. The interview value is not reciting definitions; it is predicting what the program does and preventing leaks, dangling references, and unintended copies.

Then review the STL as a set of trade-offs. Compare vector, deque, list, map, unordered_map, set, and priority queues in terms of access pattern, allocation, locality, iterator invalidation, and complexity. Know why an asymptotically acceptable choice can still perform badly when it fragments memory or makes the CPU chase pointers.

Finally, cover const correctness, templates, virtual dispatch, exceptions, undefined behavior, alignment, and basic compilation and linking. You do not need to perform compiler archaeology, but you should explain the observable consequences of your design. A strong answer separates what the C++ standard guarantees from what one compiler usually happens to do.

Concurrency and performance: correctness comes first

Concurrency questions should begin with shared state and an invariant. Identify which operations must appear atomic, what ordering is required, and how the program shuts down. A mutex around a small critical section may be better than a complicated lock-free design if it meets the throughput and latency objective.

Review mutexes, condition variables, atomics, lock ordering, deadlocks, producer-consumer queues, and thread-safe cancellation. Understand contention and false sharing well enough to recognize them, but avoid claiming that atomics automatically make a system fast. Lock-free code adds proof and maintenance costs that must be justified by measurement.

For performance, discuss representative benchmarks, warm-up, percentiles, throughput, and tail latency. Profile before optimizing. Reducing one average from 20 microseconds to 15 microseconds is not helpful if the true requirement is a stable p99 below 50 microseconds and the change creates rare stalls.

Low-latency trading systems: follow one event end to end

Old Mission's official engineering description says its systems consume market data, run models, interact with exchanges, and track positions, orders, and trades. That makes low-latency systems a relevant preparation domain. It does not prove that every intern receives a dedicated system-design round.

A good practice method is to follow one event. A feed handler receives a venue message, validates sequence and timestamp, normalizes it, and updates an order book. A strategy reads that state, produces an action, passes pre-trade risk checks, and sends an order. The system then handles acknowledgements, fills, cancels, positions, and recovery.

At each step, ask what can be duplicated, delayed, reordered, or lost. Discuss bounded queues, backpressure, memory allocation, serialization, batching, data locality, and replay. The strongest answer protects correctness before shaving latency, then measures the trade-off with a workload that resembles production.

Learn enough market structure to explain the software

You should be able to define a bid, ask, spread, limit order, market order, fill, cancel, position, and basic pre-trade risk check. Understand that a market maker generally posts prices and manages inventory and risk while supplying liquidity. That vocabulary helps you explain the purpose of an order book or execution path.

Keep the boundary clear. The internship posting asks for interest in markets and how software supports them, not prior professional finance experience. If asked why trading technology interests you, connect the domain to objective feedback, demanding reliability, rich systems problems, and direct collaboration rather than claiming a trading strategy you cannot defend.

Prepare one project deep dive

Choose a project that lets an interviewer move from product context to code. In two minutes, explain the user, constraint, architecture, your contribution, and measured result. Then prepare follow-ups about one bug, one rejected design, one performance measurement, one test strategy, and one thing you would change.

If the project is in C++, discuss ownership, failure handling, observability, and performance evidence. If it is in Python or TypeScript, explain why that language fit the workload and where a lower-level component might or might not help. Relevance comes from engineering judgment, not forcing every project into a trading story.

Old Mission emphasizes teamwork and immediate responsibility on its working-at-Old-Mission page. Prepare concise examples of learning an unfamiliar system, receiving direct feedback, resolving a technical disagreement, and finding a correctness issue before release.

A seven-day Old Mission preparation plan

Day	Focus	What to do
Day 1	Diagnostic	Solve one medium coding problem, explain C++ ownership, and give a two-minute project overview. Record every weak point.
Day 2	Coding	Practice arrays, hashing, trees, and graph traversal with explicit invariants and edge-case tests.
Day 3	C++	Review lifetime, RAII, move semantics, containers, iterator invalidation, and undefined behavior.
Day 4	Concurrency	Implement a thread-safe component, test race conditions, and explain lock ordering and shutdown.
Day 5	Trading systems	Trace market data through an order book, risk checks, execution, fills, replay, and monitoring.
Day 6	Performance and projects	Profile one program, defend one optimization, then run a project deep dive with technical follow-ups.
Day 7	Mixed mock	Combine coding, C++, systems, and behavioral questions; finish by reviewing the exact instructions in your invitation.

Frequently asked questions

Does Old Mission send an OA for the 2027 SWE internship?

Old Mission does not publicly document one universal 2027 intern OA platform or format. Engineering candidates have reported tests in other cycles and roles, including an in-person test in 2026, but the provider, location, timer, and question mix can change. Follow your own invitation rather than assuming an older Codility, HackerRank, or onsite format.

Is C++ required for the Old Mission internship interview?

The official role says candidates should be comfortable with one or more of C++, Python, or TypeScript, while the work itself supports C++ trading applications. That makes C++ a high-priority preparation area even if an assessment permits another language. Be ready to discuss lifetime, containers, performance, and concurrency in addition to writing code.

Do I need finance experience?

No. The current posting explicitly says finance experience is not required. Learn basic market, order, fill, position, and risk vocabulary so you can reason about the software's users and constraints. Spend most of your preparation on coding, C++, systems, testing, performance, and clear communication.

Will there be a low-latency system-design interview?

That round is not publicly confirmed for every 2027 intern. Low-latency preparation is useful because Old Mission builds high-performance trading systems and the internship supports C++ trading tools. Treat it as role-relevant depth, not as a promise that your loop contains a named low-latency round.

Who is eligible for the 2027 internship?

The current Chicago posting targets BS or MS students in CS, Computer Engineering, or a similar technical field, with at least junior standing, a minimum 3.0 GPA, and graduation in December 2027 or May 2028. It lists June 1, 2027 as the required start date. Verify the live posting before applying because requirements can change.

Final takeaway

The best Old Mission SWE Intern 2027 preparation combines clean coding, precise C++, and systems judgment grounded in electronic trading. Do not spend the week memorizing an unverified OA format. Build skills that remain useful whether the first step is a test, a technical screen, or an in-person exercise.

Attempt each prompt before opening the written solution, log the first incorrect assumption, and repeat the same skill two days later. That practice loop turns C++ and low-latency vocabulary into evidence you can demonstrate under interview pressure.

Sources and Further Reading

• Old Mission 2027 Software Engineer internship listing
• Old Mission company and market-making platform
• Old Mission engineering and team overview
• Working at Old Mission

Research note: This guide was checked on August 25, 2026. Old Mission may change interview stages, assessment platforms, languages, or timelines. Your current posting, recruiter messages, and assessment invitation remain authoritative.