Software Engineering Fundamentals interview questions

Showing 301–330 of 1208 results

• Define a Reliable Trade-Reconciliation Library ContractMedium

  Define trade-reconciliation contracts and OOP boundaries with exact values, timestamp tolerance, partial-fill questions, deterministic policy ownership, and traceable breaks.

  Citadel SecuritiesSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Design a Top-Ten Trade Query with Exact AmountsMedium

  Design a top-ten trade query around an explicit ranking contract, exact monetary aggregation, bounded heaps, timestamp boundaries, and mutable-score streaming tradeoffs.

  Citadel SecuritiesSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Detect Currency Arbitrage and Return a Profitable Conversion CycleMedium

  Given a list of currency conversion rates, determine whether an arbitrage opportunity exists and return a sequence of conversions that ends in the starting currency with more money than it began with. Tests graph modeling, cycle detection, reconstruction of the profitable sequence, and handling of floating-point precision.

  Citadel SecuritiesSoftware EngineerSoftware Engineering FundamentalsOnsite
• Thread-Safe Producer-Consumer Queue: Mutex, Then Spin Lock, Then Lock-FreeMedium

  Implement a thread-safe producer-consumer queue in C++, first with a mutex, then with a spin lock, then as a lock-free design with explicit memory ordering. Tests the C++ memory model, contention and cache effects, blocking versus spinning, and where memory is allocated on the hot path.

  Citadel SecuritiesSoftware EngineerSoftware Engineering FundamentalsOnsite
• Design an encrypted key-value store with loginMedium

  This question evaluates a candidate's understanding of secure authentication, key management, and applied cryptography for encrypting data at rest within a user-scoped key–value store.

  CloudflareSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain debugging methodology for production issuesEasy

  This question evaluates a candidate's troubleshooting and incident-response skills, including root-cause analysis, systems-level reasoning, and prioritization under production constraints.

  CloudflareSoftware EngineerSoftware Engineering FundamentalsHR Screen
• Reason About Duplicate Data and Scaling in SparkHard

  This problem tests the ability to design an idempotent, scalable data deduplication pipeline in Apache Spark while considering distributed systems constraints like data skew and state management.

  CognitivSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Build a Credit Card Form With Validation and Linked Input FieldsMedium

  A front-end UI coding question: build a credit card form with card number, name, expiry and security code, where every field is validated and the fields are linked, so the detected card network changes formatting and security-code rules. It tests state design, caret-safe input formatting, error timing, accessibility and safe handling of card data.

  CohereFrontend EngineerSoftware Engineering FundamentalsOnsite
• Build an LLM-driven text-game agentMedium

  This question tests the ability to design a robust pipeline for an LLM-based agent interacting with a stateful environment, focusing on context management, output validation, and error recovery.

  CohereMachine Learning EngineerSoftware Engineering FundamentalsOnsite
• Replace a Heuristic Terminal Text Game's Python Logic With LLM CallsMedium

  A live coding round: replace the heuristic Python implementation of a terminal text game with one driven by an LLM while keeping the game playable end to end. AI assistants are allowed, but the round judges your own implementation and debugging, including validating model output, fallbacks, and tests with a fake model.

  CohereMachine Learning EngineerSoftware Engineering FundamentalsOnsite
• Build Task Management Through Records, Search, Assignment, and CompletionMedium

  Implement an in-memory task management system that tracks task lifecycles, assignments, and deadlines with efficient indexing and querying. Tests data structure design, state management, and multi-field sorting.

  CoinbaseSoftware EngineerSoftware Engineering FundamentalsOnline Assessment
• Debug and Extend Cursor QueriesHard

  This question evaluates understanding of iterator/cursor semantics, stateful side effects and mutation, practical debugging and trace reasoning, and basic query API design such as adding limit or order_by features.

  CoinbaseSoftware EngineerSoftware Engineering FundamentalsOnsite
• Design a Timestamped Cloud Credit Ledger with Rebates, Merges, and HistoryHard

  Design an in-memory cloud credit ledger that processes top-ups, charges with delayed deterministic rebates, account merges with canonical alias resolution, historical balance lookups, and spending leaderboards.

  CoinbaseSoftware EngineerSoftware Engineering FundamentalsOnline Assessment
• Design a task management system with TTLMedium

  This question evaluates the ability to design in-memory data models and algorithms for time-based task assignment semantics, including TTL-based expiration, per-user quotas, priority-based listing, and correct handling of multiple concurrent assignments and completion rules.

  CoinbaseSoftware EngineerSoftware Engineering FundamentalsOnline Assessment
• Evolve Cursor Pagination Without Breaking ClientsMedium

  This problem tests the ability to design stable, deterministic cursor-based pagination systems that handle non-unique sort keys and schema evolution without breaking backward compatibility.

  CoinbaseBackend EngineerSoftware Engineering FundamentalsOnsite
• Extend a Banking Interface with Scheduled Payments and Account MergesHard

  Implement an in-memory transactional banking system supporting scheduled payments, deterministic tick-based execution, idempotency, and account merging with balance consolidation and redirect tracking.

  CoinbaseSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Fee-Maximizing Block Assembly from a Mempool with Child-Pays-For-ParentMedium

  A coding question on assembling a cryptocurrency block from a very large mempool: pick transactions that maximize fees within a fixed block size using a fast heuristic, then extend the selection to parent links and Child-Pays-For-Parent incentives. An optional part asks for the minimum fee a child must pay to pull its parent into the next block.

  CoinbaseSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement a Reusable Dropdown ComponentHard

  This question evaluates skills in reusable frontend component design, including API design, state management (controlled vs uncontrolled), event handling, keyboard navigation, and accessibility (roles, focus behavior, and ARIA) for production-ready UI components.

  CoinbaseFrontend EngineerSoftware Engineering FundamentalsOnsite
• Implement a blog feed with fetching and stateMedium

  This problem tests your ability to handle asynchronous data fetching, state synchronization, and UI interactions in React, specifically managing a list of blog posts with optimistic updates and sorting.

  CoinbaseSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement debounced async autocomplete inputMedium

  Implement debounced async autocomplete input evaluates requirements, assumptions, structured reasoning, trade-offs, and verification in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

  CoinbaseSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement debounced autocomplete componentMedium

  This interview question evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer for Implement debounced autocomplete component states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

  CoinbaseSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Pick Mempool Transactions for a Block with Parent Dependencies and CPFPHard

  A multi-part coding problem about filling a block of capacity 100 from a large, unsorted mempool of transactions with fees and sizes, where speed matters more than optimality. Later parts add parent transactions that must be included first, child-pays-for-parent across multi-level chains, and an optional minimum fee for a new child.

  CoinbaseSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Build and Review an Employee Expense Reimbursement ApplicationMedium

  This problem tests your ability to design a simple RESTful API and implement core CRUD operations with server-side validation for an expense tracking system.

  Color HealthSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Generate a Semantic Dependency Graph from Tool SchemasMedium

  Design an algorithm to construct an explainable dependency graph between API tools by matching output and input schemas and identifying unresolved requirements.

  ComposioSoftware EngineerSoftware Engineering FundamentalsOnline Assessment
• Design an LRU Cache with a Constant-Time AverageMedium

  Design a fixed-capacity LRU cache whose get, put, and current-value average operations all run in expected constant time. Reason through map and recency-list invariants, running-sum updates, replacement and eviction edge cases, numeric precision, overflow, and tests that catch aggregate or ordering bugs.

  ConfluentSoftware EngineerSoftware Engineering FundamentalsOnsite
• Document Search: Exact Word Match, Non-Adjacent Phrase Match and AND/OR QueriesMedium

  A progressive coding round that builds search over a collection of documents. It starts with exact whole-word lookup, extends to multi-word queries whose words need not be adjacent, and ends with words combined by AND and OR, testing inverted indexes, set operations and clarifying ambiguous query semantics.

  ConfluentSoftware EngineerSoftware Engineering FundamentalsOnsite
• Explain Linux Command Execution, Filesystems, and IsolationMedium

  Explain what Linux does from shell parsing through process creation, exec, waiting, and exit status, then trace paths, permissions, file descriptors, directories, procfs, and network inspection. Compare containers and virtual machines through their actual isolation boundaries and operational trade-offs.

  ConfluentSoftware EngineerSoftware Engineering FundamentalsOnsite
• Explain variadic functionsHard

  Explain variadic functions evaluates requirements, assumptions, structured reasoning, trade-offs, and verification in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

  ConfluentSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement tail -n for a Very Large FileMedium

  Implement the core of tail -n for a seekable file that may be many gigabytes without scanning it all when the requested suffix is small. Work through backward block reads, chunk boundaries, trailing-newline semantics, bounded memory, binary-versus-text handling, safe decoding, and mutation assumptions.

  ConfluentSoftware EngineerSoftware Engineering FundamentalsOnsite
• Machine Coding: Word Search and Ordered Phrase Search Across a List of DocumentsMedium

  A machine-coding exercise that asks you to build a search component over a list of text documents, first finding the documents that contain a given word and then those where a phrase's words appear in the same sequence. It tests tokenization choices, index design, and handling of repeated words and edge cases.

  ConfluentSoftware EngineerSoftware Engineering FundamentalsOnsite