Software Engineering Fundamentals interview questions

Showing 631–660 of 1208 results

• Code Review: Thread Safety of a Python Compute-and-Cache FunctionMedium

  Review a Python function that checks a dictionary cache, runs an expensive computation on a miss, and stores the result, assuming concurrent callers. It probes thread safety under simultaneous misses, making the computation run once per input, where to place a lock without serializing cache hits, and how Python dictionaries behave under concurrent reads and writes.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Compare Merge Sort with Factorial and Randomized Inefficient SortsHard

  Tests deep understanding of sorting algorithms, contrasting optimal divide-and-conquer strategies (Merge Sort and its adaptive variants) against factorial and randomized paradigms (Permutation Sort and Bogo Sort) across worst-case and expected complexity bounds.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Compare processes and threads in Linux and PythonMedium

  This question evaluates understanding of operating-system level concurrency versus language-level concurrency, specifically distinctions between processes and threads on Linux, the Global Interpreter Lock in Python, and trade-offs between Python threading and multiprocessing for performance.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Debug a Java CSV Export Function for Output and Performance BugsMedium

  A debugging exercise on a small Java function that converts rows of string fields into CSV text for import by another system. You find what is wrong with its output and why it slows down sharply on large exports, then fix it. It tests string handling, the cost of building strings in loops, and edge-case tests.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Design a Deliberately Inefficient Sorting Algorithm and Analyze Its ComplexityEasy

  An algorithms discussion question that asks for a deliberately inefficient but correct sorting algorithm and a careful analysis of its running time. It tests complexity reasoning about extremely fast-growing costs, worst-case versus expected time, and how such a sort compares with the lower bound for comparison sorting.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Design the Worst Correct Sorting Algorithm and Analyze Its ComplexityMedium

  Asks you to propose the worst sorting algorithm that is still correct, explain how it works, argue that it always terminates with sorted output, and analyze its best-case and worst-case time and space. It tests counting arrangements, reasoning about factorial growth and stating what makes such a question well defined.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain what happens when opening a websiteMedium

  This question evaluates understanding of the end-to-end web request lifecycle, including DNS resolution, TCP/TLS handshakes, HTTP(S) exchanges, CDN and load balancer behavior, server-side handling, and the browser rendering pipeline.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Find the Production Bugs in a Dictionary Cache Around an Expensive ComputationMedium

  Review a short Python function that caches the results of an expensive computation in a dictionary, and identify what breaks in a long-running, concurrent production service. Tests reasoning about memory growth, eviction policy, concurrent cache misses, error handling, and input validation.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Make a Dict-Based Memoization Cache Safe for Concurrent ThreadsMedium

  A memoization cache built on a plain Python dictionary wraps an expensive function and is now called from many threads at once. The question asks what goes wrong and how to fix it, testing race-condition analysis, lock scope and its throughput cost, duplicate-work prevention, and exception handling for waiting callers.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Review a Hand-Rolled Python CSV Serializer for Correctness and Performance BugsMedium

  A code review question on a short Python function that turns a table of rows into CSV text. Candidates must find its correctness and performance problems and write a fixed version, which tests delimiter handling, string building in Python, non-string cells, CSV quoting and escaping rules, and how to verify the fix.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Review an Asynchronous Cache for Races, Memory Growth, and Thread SafetyHard

  Tests understanding of asynchronous race conditions, memory leaks, and eviction in single-threaded event loops versus multithreaded synchronization in languages like C++.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Sorting Complexity: Beating O(n^2), Quicksort's Worst Case, and a Slower SortMedium

  A verbal sorting-theory discussion: explain how to sort faster than quadratic insertion sort, identify quicksort's worst case, count the non-empty subsequences and the permutations of an n-element array, and design a correct sort that is deliberately slower than O(n^2). It tests asymptotic analysis, recurrence reasoning, and basic combinatorics.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Stripe Payment Integration: Error Handling, Idempotent Retries and Payment StorageMedium

  Explain how to add a Stripe payment integration to a backend service: how to handle errors and retries without charging a customer twice, what payment data to store, and which database to use given ACID and availability needs. Tests idempotency, failure handling, and data modeling for payments.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• The Worst Possible Sorting Algorithm and How to Enumerate Every PermutationMedium

  A verbal algorithms question: name the worst sorting algorithm that still always sorts correctly, analyze its running time, and explain how you would compute every permutation of the input exactly once. It tests reasoning about factorial complexity and knowledge of permutation enumeration methods.

  MercorSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Design a Common Data Class to Normalize Different API ResponsesMedium

  Design a common data class that can hold API responses describing the same kind of record but differing in field names, nesting, ID types and timestamp formats, plus the code that maps each response into it. It tests data modeling, normalization, handling of missing and extra fields, and how the records would be stored in a database.

  MergeSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Org Chart from a Reporting List: Count Orgs, Print by Level, Find a Common ManagerMedium

  Given a company's employees as (id, title, reports_to) tuples with heads reporting to None, count the separate orgs, print employees level by level, and find the first manager two employees share. It tests building a tree from manager pointers, level-order traversal, ancestor queries and edge cases under a tight time limit.

  MergeSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Analyze Minimum Completion Time for Target Courses in a Prerequisite DAGHard

  Analyze the minimum time needed to finish target courses and only their transitive prerequisites in a DAG. Distinguish total study effort from elapsed time with parallel courses, count shared prerequisites once, exclude unrelated nodes, and detect reachable cycles.

  MetaSoftware EngineerSoftware Engineering FundamentalsOnsite
• Design a Concurrent, Memory-Bounded Tally ServiceMedium

  This problem tests the ability to design a high-throughput, memory-efficient data structure for time-series counting that balances concurrency, accuracy, and storage constraints.

  MetaSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Design a String Calculator with Explicit Grammar and Evaluation RulesEasy

  This problem tests the ability to implement a parser for basic mathematical expressions, specifically focusing on handling operator precedence and parentheses using a stack-based approach.

  MetaSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Design a Trade Ledger ClassEasy

  This problem evaluates your ability to design a class interface that maintains an ordered collection of events and allows efficient retrieval based on time-based criteria.

  MetaSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Design an Expected O(1) Randomized ContainerMedium

  Design a distinct-element container with expected constant-time insertion and uniformly random removal. The discussion covers mutation invariants, uniformity, empty-state behavior, expected complexity, deterministic randomness tests, and how duplicate or concurrent variants would change the contract.

  MetaSoftware EngineerSoftware Engineering FundamentalsOnsite
• Design and Evaluate a Solver for a 36-Card Sum-Fifteen GameHard

  Tests state-space search (DFS with memoization), heuristic design, and simulation benchmarking for a deterministic 36-card solitaire game.

  MetaSoftware EngineerSoftware Engineering FundamentalsOnsite
• Diagnose a Single-Server Crash with Concrete Linux EvidenceMedium

  Walk through a single-server crash investigation using Linux service, kernel, memory, disk, and boot evidence while planning safe recovery.

  MetaSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Execute Dependency-Constrained Work at ScaleMedium

  This problem tests the ability to design an execution engine that manages task dependencies using a directed acyclic graph (DAG), respects concurrency limits, and handles task failures.

  MetaSoftware EngineerSoftware Engineering FundamentalsOnsite
• Explain ACID and isolation levelsMedium

  This question evaluates a candidate's knowledge of database transactions, the ACID properties (Atomicity, Consistency, Isolation, Durability), and common isolation levels (Read Uncommitted, Read Committed, Repeatable Read, Serializable), testing competency in concurrency control and data consistency.

  MetaSoftware EngineerSoftware Engineering FundamentalsOnsite
• Implement paginated, sortable dynamic table 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 paginated, sortable dynamic table component states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

  MetaSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement, Debug, and Optimize a React TableHard

  Implement, Debug, and Optimize a React Table 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.

  MetaSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Troubleshoot a production server outageMedium

  This question evaluates a candidate's competency in observability, incident response, and Linux/server operations, including troubleshooting production outages, isolating latency causes, identifying running processes and services, and recognizing finite resource bottlenecks.

  MetaSite Reliability EngineerSoftware Engineering FundamentalsTechnical Screen
• Troubleshoot a website outage with disk fullMedium

  This question tests your systematic approach to diagnosing a production service outage caused by resource exhaustion and your ability to implement short-term and long-term mitigation strategies.

  MetaSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain how you use AI tools in developmentMedium

  This question evaluates a developer's familiarity with AI-assisted development tools, practical experience integrating them into workflows, and understanding of associated governance, security, and data-handling concerns.

  MetropolisSoftware EngineerSoftware Engineering FundamentalsTechnical Screen