Interview guides · Becoming

Becoming Software Engineer Interview Guide

Becoming Software Engineer interview guide: reported rounds, coding, system design and behavioral questions, with approaches and a 7-day plan.

The 60-second brief

The material candidates share about Becoming does not spell out a product line. It describes software engineers working with cross-functional teams on projects that span robotics, optics and biomaterials, and the topic breakdown lists Software Engineering, Robotics Engineering, Microphysiological Systems, Optics Engineering and Systems Engineering. The listed responsibilities are building and maintaining software applications, helping define requirements with product and design colleagues, taking part in code reviews, debugging, and working in agile cycles. Treat the domain topics as context to ask about in your own conversations, since the reported questions themselves are general software engineering questions.

This guide is for candidates interviewing for the Software Engineer role at Becoming. Candidates describe the requirements as proficiency in Python, Java or C++, experience with development frameworks and tools, solid algorithms, data structures and software design, a computer science or related background, and roughly 2-5 years of experience. Cloud platforms such as AWS or Azure, machine learning or data analysis, and interface design are listed as nice-to-haves. The guide covers all four reported rounds and the reported questions in the technical, system design, behavioral, problem-solving and coding groups.

Candidates report four rounds over roughly 3-5 weeks: Initial Screening, Technical Interviews, Collaborative Sessions and Final Interviews. The reported questions fall into technical, system design, behavioral, problem-solving and coding groups.

Focus areas

Software Engineering
Robotics Engineering
Microphysiological Systems

Overview

The reported questions are broad rather than tied to one product. The coding group is the classic set: reverse a linked list, implement binary search, detect whether a string has all unique characters, explain the complexity of a sorting solution, and solve a dynamic programming problem. The design group asks for a URL shortening service, a microservices architecture, a data storage solution, authentication in a distributed system, and a system you built yourself. Prepare these as spoken answers with code or a diagram, not as recalled definitions.

The problem-solving group is wider than it first looks. It mixes a data question (missing values in a dataset), a machine learning question (how to evaluate a model), a production bug report, an unfamiliar-problem question and a speed-versus-quality question. The requirements candidates describe list machine learning or data analysis as a nice-to-have, so a short, correct answer on evaluation metrics and imputation is enough; you do not need depth beyond what a software engineer would use.

Candidates describe the evaluation areas as technical proficiency (a language from Python, Java or C++, plus tools such as Git and Docker, testing and debugging), problem-solving, collaboration and communication, and adaptability. That points to a loop where your language choice, your reasoning out loud and your stories about working with other people all matter. Pick one language and stay in it for every coding answer, and have five behavioral stories ready that you can reshape for conflict, prioritization, leading, feedback and motivation questions.

The role description mentions cross-functional work and projects across robotics, optics and biomaterials. Nothing reported says you will be asked domain questions in those fields, so spend your preparation on the general engineering questions above, and use your own questions to the interviewers to learn which team and which kind of software you would join.

The Becoming interview process

Candidates describe four stages, in this order, over roughly 3-5 weeks. Specifics vary by team and role, and the reports do not pin particular questions to particular rounds.

Initial Screening

Candidates describe Initial Screening as a first conversation about basic qualifications and fit for the role. Treat it as a check that your background matches the requirements candidates describe: a language from Python, Java or C++, tools and frameworks, algorithms and data structures, and roughly 2-5 years of software experience. Be ready to say which language you are strongest in and why, since that is a reported question, and to describe one project in terms of what you built and decided yourself.

What to demonstrate

Whether your experience matches the listed requirements for the role
How clearly you describe your own projects and technical choices
Which language you are most comfortable in and your reasons for it

How to prepare

Write a short answer to "What programming languages are you most proficient in, and why?" that names one primary language, one project where you used it, and one limitation you have worked around
Map your last two projects to the listed requirements: frameworks and tools, algorithms and data structures, testing and debugging
Prepare two or three questions about the team, the kind of software it builds and how the cross-functional work is organized

Technical Interviews

Technical Interviews are reported to focus on coding, system design and domain expertise. This is the stage where the coding questions (linked list reversal, binary search, unique characters in a string, sorting complexity, dynamic programming) and the design questions (URL shortener, microservices, data storage, distributed authentication) are practised. Code in the language you named earlier, state complexity out loud, and for design questions fix the requirements and the read and write paths before you draw components.

What to demonstrate

Working code and correct complexity analysis on standard data structure and algorithm problems
Ability to design a service and defend component and storage choices
Knowledge of the tools and practices candidates describe: Git, Docker, testing and debugging

How to prepare

Write and run the linked list reversal and binary search functions from memory, including empty-input and single-element cases
Outline the URL shortener end to end: key generation, storage, redirect path, caching and what happens on a collision
Prepare a three-sentence answer on how you keep code maintainable, using one concrete practice such as review checklists, tests around the risky path or small pull requests

Collaborative Sessions

Collaborative Sessions are described as assessing problem-solving in real-time scenarios, and the problem-solving question group fits that format: a production bug report, an unfamiliar problem, a dataset with missing values, evaluating a machine learning model. Expect to work a problem with another person rather than deliver a finished answer, so narrate assumptions, ask what is known, and revise your approach when new information arrives.

What to demonstrate

Structured problem-solving on a scenario you have not seen before
How you reason aloud and adjust when the problem changes
Collaboration while working the problem with another person

How to prepare

Rehearse a fixed sequence for the production bug question: reproduce, check recent changes, read logs and metrics, narrow the scope, fix, add a regression test, write up the cause
Prepare a two-step answer for missing values: find out why they are missing, then choose between dropping, imputing and flagging
Practise saying your assumptions and your next step aloud while solving a problem you have never seen

Final Interviews

Final Interviews are reported to evaluate technical ability and team collaboration skills together. Prepare for both a technical conversation and the behavioral questions on conflict, prioritization, leading a project, feedback and motivation. Bring stories where you made the decision and can name the result, and be ready to go back over a design or coding topic from earlier in the loop with new constraints.

What to demonstrate

Technical depth across the areas covered earlier in the loop
How you work with teammates, take feedback and handle disagreement
How you explain technical decisions to people outside your specialty

How to prepare

Finish five stories in situation, action, result form and tag each with the behavioral question it answers best
Prepare one system you designed yourself, with the trade-offs you chose and the one you would reverse today
Review your earlier design outlines and write down what changes if traffic grows tenfold or a dependency is down

Where candidates lose points

Reversing a linked list while losing the rest of the list, or failing on an empty or single-node list

Save the next pointer before you rewrite the current one, track previous and current, and run the empty, one-node and two-node cases by hand before you say you are finished.

Writing binary search with an off-by-one bound or an infinite loop, and giving complexity without saying what the input must satisfy

Choose one invariant (inclusive bounds, or half-open), use it consistently, say the array must be sorted, and test duplicates, a missing target and a one-element array. Then state O(log n) time and O(1) space.

Answering the URL shortener or microservices design by listing components with no requirements or trade-off

Start with scale, read-to-write ratio and what counts as failure. Describe key generation, storage, cache and redirect path separately, and say what you would trade away, such as strict uniqueness for lower latency.

Giving a model-evaluation or missing-values answer that names one technique and stops, such as accuracy only or always dropping rows

Ask what the model is used for and how imbalanced the labels are, then pick metrics (precision, recall, ROC AUC, a held-out test set) to match. For missing data, find out why values are missing before choosing between dropping, imputing and flagging.

Telling behavioral stories entirely in "we" with no decision of your own, or with no result

For each story, write one sentence starting "I decided" and one measurable or observable outcome. If you cannot name either, choose a different story.

Questions & practice

Write a function to reverse a linked list.

Medium · Coding / Algorithms

Approach

Iterative three-pointer solution: prev = None, curr = head; loop while curr: nxt = curr.next, curr.next = prev, prev = curr, curr = nxt; return prev as the new head. O(n) time, O(1) extra space.
Recursive alternative: reverse the rest of the list, then set head.next.next = head and head.next = None; O(n) time but O(n) call stack, which risks a stack overflow on long lists (CPython's default recursion limit is 1000).
Edge cases: empty list, single node, two nodes; make sure the old head's next ends up null so no cycle remains, and return the new head rather than the old one.
Test by building a list from an array, reversing it and converting it back to an array to compare, including the empty and one-element cases.
Mention the common variants: reverse only positions left to right, reverse in groups of k, and for a doubly linked list swap each node's prev and next pointers.

Follow-up

Reverse only the nodes between positions left and right in one pass.
Reverse the list in groups of k nodes.
Check whether a linked list is a palindrome using O(1) extra space.

Explain the time complexity of your solution to a sorting problem.

Medium · Coding / Algorithms

Approach

Anchor on the lower bound: any comparison sort needs Omega(n log n) comparisons in the worst case, so a sort-then-scan solution is O(n log n) overall, dominated by the sort; state the extra memory the sort uses as well.
Compare the main algorithms: merge sort is O(n log n) in every case, stable, with O(n) extra memory; quicksort averages O(n log n) but degrades to O(n^2) with bad pivots (for example a first-element pivot on sorted input) and is not stable; heapsort is O(n log n) worst case with O(1) extra space but not stable; insertion sort is O(n^2) yet O(n) on nearly sorted input.
Know the library sorts: Python's sorted and list.sort use Timsort (stable, O(n log n) worst case, O(n) on already sorted input); Java sorts primitives with dual-pivot quicksort and objects with a stable TimSort; C++ std::sort is an introsort with an O(n log n) worst case since C++11, and std::stable_sort is the stable option.
Use non-comparison sorts when keys allow: counting sort in O(n + k) for integers in a range of size k, radix sort in O(d * (n + b)) for d-digit keys in base b.
Name the deciding properties when choosing: stability, memory limits, worst-case guarantees, and whether the input is nearly sorted.

Follow-up

Why is quicksort often faster than merge sort in practice despite its worse worst case?
How would you sort 100 GB of data on a machine with 8 GB of RAM?
Give an example where sort stability changes the result.

How would you implement a binary search algorithm?

Medium · Coding / Algorithms

Approach

State the precondition: the array is sorted, or more generally a predicate is monotonic over the search range. Iterative version: lo = 0, hi = n - 1; while lo <= hi: mid = lo + (hi - lo) // 2; return mid on a match, move lo = mid + 1 or hi = mid - 1 otherwise; return -1. O(log n) time, O(1) space.
Explain the midpoint: (lo + hi) / 2 can overflow a 32-bit int in Java or C++, so write lo + (hi - lo) / 2; Python integers do not overflow.
Write the boundary variant: lower bound (first index with a[i] >= target) on the half-open range [lo, hi) with while lo < hi: if a[mid] < target then lo = mid + 1 else hi = mid; this handles duplicates and yields first or last occurrence.
Edge cases: empty array, target below the minimum or above the maximum, a single element, duplicates, and an infinite loop when lo = mid is set without the + 1.
Know the library calls: Python bisect_left and bisect_right, C++ std::lower_bound and std::upper_bound, and Java Arrays.binarySearch, which returns -(insertion point) - 1 when the key is absent. Mention binary search on the answer, such as the minimum ship capacity to deliver within D days.

Follow-up

Find a target in a sorted array that has been rotated.
Return the first and last positions of a value that appears many times.
Use binary search on the answer to find the minimum speed that finishes a workload by a deadline.

Describe how you would detect if a string has all unique characters.

Medium · Coding / Algorithms

Approach

Clarify the character set first: 128-character ASCII, extended 8-bit, or full Unicode; whether comparison is case-sensitive; whether spaces count.
Hash-set scan: add each character and return false at the first repeat; O(n) time, O(min(n, k)) space for an alphabet of size k. The one-liner len(set(s)) == len(s) is correct but has no early exit.
For a fixed alphabet, use a boolean array of 128 or a bit vector in one integer for 'a' to 'z' (26 bits); by the pigeonhole principle a string longer than the alphabet size cannot be unique, so return false immediately, which bounds the work by the alphabet size.
Without extra data structures: sort a copy of the characters in O(n log n) and compare neighbours (strings are immutable in Python and Java, so sorting needs a copy), or compare all pairs in O(n^2) with O(1) space.
For Unicode, Java's char is a UTF-16 code unit, so emoji and other supplementary characters take two chars; iterate over codePoints(), and normalize (for example NFC) if 'character' means what a user sees.

Follow-up

Solve it without any additional data structure.
What if the input is a stream too large to hold in memory?
How does your answer change for arbitrary Unicode input?

Solve a problem involving dynamic programming and explain your approach.

Medium · Coding / Algorithms

Approach

Justify DP: the problem has optimal substructure and overlapping subproblems, so plain recursion repeats work and is exponential; caching each subproblem's answer removes the repetition.
Define the state, recurrence, base cases and evaluation order explicitly. Example, minimum coins for an amount: dp[0] = 0; dp[a] = min over coins c <= a of dp[a - c] + 1; unreachable amounts stay at infinity and map to -1. O(amount * number_of_coins) time, O(amount) space.
Compare top-down memoization (natural to write, computes only reachable states, but limited by recursion depth) with bottom-up tabulation (no recursion, allows space reduction such as keeping two rows, which brings longest common subsequence from O(mn) to O(min(m, n)) space).
Reconstruct the actual solution, not just the optimal value, by storing the choice made at each state or backtracking through the table.
Know the standard families and their costs: 0/1 knapsack in O(nW) (pseudo-polynomial in the capacity W), edit distance in O(mn), longest increasing subsequence in O(n^2) or O(n log n) with binary search over tail values.

Follow-up

Can you reduce the space your table uses?
Return the items or steps that make up the optimal answer, not only its value.
Why is the knapsack DP called pseudo-polynomial?

Can you explain how you would optimize a database query?

Medium · Technical / Domain Questions

Approach

Measure before changing anything: run EXPLAIN ANALYZE (PostgreSQL) or EXPLAIN (MySQL), find the node that takes the time (a sequential scan on a large table, a nested loop with a big outer side, a sort spilling to disk), and compare estimated with actual row counts; a large gap points to stale statistics, fixed with ANALYZE.
Index for the predicate: a B-tree on the WHERE, JOIN and ORDER BY columns; in a composite index, put equality columns before the range column; a covering index (INCLUDE in PostgreSQL) allows an index-only scan. Name what makes an index unusable: a function on the column (LOWER(email) without an expression index), a LIKE pattern starting with %, an implicit type cast, or low selectivity.
Rewrite the query itself: select only the needed columns instead of SELECT *, filter before joining and aggregating, replace a correlated subquery with a join or EXISTS, and use keyset pagination (WHERE id > :last_id ORDER BY id LIMIT n) because a large OFFSET still reads and discards the skipped rows.
Check the application side: an ORM issuing one query per row (the N+1 pattern) is fixed by batching with IN or a join, not by indexing.
State the trade-offs and verify: every extra index slows inserts and updates and costs storage; beyond indexing, consider caching, a materialized view, read replicas or time partitioning, and confirm the gain by comparing plans and timings on production-sized data.

Follow-up

An index exists on the filtered column but the planner still does a sequential scan. What could explain that?
How would you speed up a slow COUNT(*) on a very large table?
What does each additional index cost on a write-heavy table?

Keep soft-deleted accounts from blocking re-registration

Easy · soft delete · unique constraints · engine differences

app_user holds user_id, tenant_id, email CITEXT, password_hash (NULL for SSO principals), email_verified_at, auth_version, status ('invited','active','suspended','deactivated'), created_at, updated_at, deleted_at. Two live accounts for one address inside a tenant must be impossible, but an address freed by a soft delete must be reusable, and the same tenant may delete and re-register it repeatedly. Write the uniqueness DDL for PostgreSQL 16, then the equivalent for MySQL 8 where partial indexes do not exist, and say what each permits once three deleted rows already hold that address.

Approach

Start from what is actually unique: not (tenant_id, email), but (tenant_id, email) among live rows. PostgreSQL says that directly — CREATE UNIQUE INDEX app_user_live_email ON app_user (tenant_id, email) WHERE deleted_at IS NULL. A full constraint over the same two columns burns the address permanently the first time someone deletes an account.
Keep case-insensitivity in the type or the index, never in the application: CITEXT as given, or UNIQUE (tenant_id, lower(email)) as an expression index where the extension is unavailable. A case-sensitive unique column is exactly how two accounts for one human appear.
For MySQL 8 the predicate has to move inside the key: add a discriminator column that is a constant 0 while the row is live and is set to user_id on delete, with UNIQUE (tenant_id, email, deleted_marker). Live rows share the constant and still collide; deleted rows differ from each other and stop colliding.
State the NULL variant and its dependency: leaving the marker NULL for deleted rows also works, because a unique index treats NULLs as distinct — true in MySQL, and true in PostgreSQL only under the default NULLS DISTINCT, which PostgreSQL 15 lets you reverse. Check the polarity against the three existing deleted rows: constant-on-live is what preserves the collision you want, and reversing it silently admits duplicate live accounts.

Follow-up

A deleted account re-registers with the same address the next day. Do the old resource rows follow the new user_id, and how does the API keep the two principals apart?
How do you honour an erasure request while resource_revision.actor_user_id still references this table?

What are the key differences between REST and SOAP APIs?

Medium · Technical / Domain Questions

Approach

Frame the category difference first: SOAP is a protocol with a fixed XML envelope (Envelope, optional Header, Body) and a contract described in WSDL/XSD; REST is an architectural style where resources have URLs and are manipulated through HTTP methods, usually with JSON representations.
Contrast how outcomes are signalled: REST uses HTTP status codes (201, 404, 409, 503) and method semantics, where GET is safe and idempotent, PUT and DELETE are idempotent and POST is not; SOAP returns errors as a SOAP Fault element in the body and usually tunnels every call through POST.
Explain the caching consequence: REST GETs can be cached by browsers, proxies and CDNs using Cache-Control and ETag; SOAP calls sent as POST get no HTTP-level caching.
Compare security and reliability: SOAP has WS-Security for message-level signing and encryption plus WS-ReliableMessaging; REST relies on TLS for transport security and on OAuth 2.0 or token schemes for authorization.
Close with when I would choose each: SOAP when a partner or legacy enterprise system requires a WSDL contract and message-level security; REST for public, browser and mobile-facing APIs where lighter JSON payloads and HTTP tooling matter.

Follow-up

How would you make a POST that creates an order safe for a client to retry after a timeout?
How do you version a REST API without breaking clients already in production?
When would you pick gRPC over both REST and SOAP?

Describe a challenging technical problem you've solved and the approach you took.

Medium · Technical / Domain Questions

Approach

Pick a problem with real technical depth that you personally drove: a performance regression, a concurrency bug, a data-corruption issue or a hard integration, not a story about a deadline alone.
Open with the constraint that made it hard in two or three sentences (scale, latency budget, missing observability, hardware or vendor limits), so the difficulty is concrete rather than asserted.
Spend most of the answer on the reasoning: the hypotheses you formed, the measurement or experiment that ruled each one in or out, and the options you weighed with the reason you rejected each alternative.
End with a measured result (latency before and after, error rate, hours saved) and what you would do differently now.
Narrate your own actions in the first person singular; a story told entirely as the team's work leaves your contribution unclear and is the most common way this answer falls flat.

Follow-up

Which alternative did you reject, and what would have made it the better choice?
How did you confirm the fix worked in production rather than only in testing?
What would you change about your approach if the same problem came up today?

How do you ensure code quality and maintainability in your projects?

Medium · Technical / Domain Questions

Approach

Describe automated gates in CI that block a merge: a formatter and linter (black and ruff for Python, Checkstyle for Java, clang-format and clang-tidy for C++), static type checks such as mypy, and a passing test suite.
Explain the test strategy: many fast unit tests, fewer integration tests, a small number of end-to-end tests; test behaviour at module boundaries rather than private internals, and add a regression test for every bug fixed.
Cover code review practice: small pull requests that can be reviewed properly, attention to naming, error handling, edge cases and test coverage of the change, and review comments that explain the reason.
Name design habits that keep code changeable: small modules with clear interfaces, dependency injection so components can be tested in isolation, avoiding abstraction before a second use case exists, and recording significant decisions in short design notes.
Give one concrete example from your own project with a number (defect rate, review time, onboarding time) and acknowledge a trade-off, for instance that a coverage percentage target can be met with tests that assert nothing.

Follow-up

How would you safely change a legacy module that has no tests?
What do you check first when reviewing a colleague's pull request?
Tell me about a time you accepted technical debt on purpose. How did you track and repay it?

What programming languages are you most proficient in, and why?

Medium · Technical / Domain Questions

Approach

Name one or two languages you have shipped production code in, and back the claim with depth rather than a list: the memory model, the concurrency model, the standard library and the build and test tooling you used.
Show language-specific knowledge that is easy to check: for Python, the GIL in CPython's default build stops threads from speeding up CPU-bound work, so use multiprocessing or native extensions; for Java, garbage collection, generics with type erasure and java.util.concurrent; for C++, RAII, unique_ptr versus shared_ptr, move semantics and undefined behaviour.
Answer the 'why' with trade-offs tied to the work: Python for fast iteration and data or ML libraries, C++ for tight latency and direct hardware control, Java for large long-running services with mature tooling.
Be honest about weaker languages and describe how you ramp up on a new one: reading idiomatic open-source code, porting a small known program, and learning the toolchain and test framework first.

Follow-up

Why does multithreading not speed up a CPU-bound task in Python, and what would you use instead?
Describe a bug you hit that was specific to your main language.
How does memory management differ between your two strongest languages?

Design a scalable URL shortening service. What components would you include?

Medium · System Design / Architecture

Approach

Pin requirements and scale first: create a short link, redirect, optional custom alias and expiry; redirects far outnumber creations, so the read path dominates. Size the key space: 7 base62 characters give 62^7, about 3.5 trillion codes.
Choose a key-generation scheme and its trade-off: a counter encoded in base62, with ID ranges handed out to each app server from a central store, never collides but produces guessable sequential codes; a truncated hash of the URL or a random code needs a uniqueness check, enforced by a unique constraint on insert with retry.
Store the mapping code -> long URL, owner, created_at, expires_at in a key-value store or a relational table keyed on the code; partition by a hash of the code so lookups stay single-partition.
Serve redirects through a cache such as Redis with LRU eviction in front of the store. Explain 301 versus 302: a 301 is cached by browsers and cuts load but hides repeat clicks; a 302 sends every click to the service so analytics stay accurate.
Keep the redirect fast by emitting click events to a queue such as Kafka and aggregating asynchronously; add rate limiting on creation and malicious-URL screening to limit abuse.

Follow-up

How do you support custom aliases without colliding with generated codes?
How would you count clicks per link at high traffic without slowing the redirect?
What happens on the redirect path if the cache cluster goes down?

How would you approach designing a microservices architecture for a new application?

Medium · System Design / Architecture

Approach

Question the premise first: for a new application with a small team, a modular monolith with clean internal boundaries is often cheaper; split into services when deployment independence, team ownership or scaling needs justify the operational cost.
Draw service boundaries around business capabilities (bounded contexts in domain-driven design), with each service owning its data; no service reads another service's tables directly.
Choose communication per interaction: synchronous REST or gRPC when the caller needs an answer now, asynchronous events through a broker such as Kafka or RabbitMQ for decoupled workflows, and an API gateway for routing, authentication and rate limiting.
Handle cross-service consistency without distributed ACID transactions: a saga with compensating actions, a transactional outbox so the database write and the event publish cannot diverge, and idempotent consumers because brokers usually deliver at least once.
Cover resilience and operations: timeouts, retries with exponential backoff and jitter, circuit breakers; Docker containers with an orchestrator such as Kubernetes, a CI/CD pipeline per service, centralized logs, metrics and distributed tracing (for example OpenTelemetry).

Follow-up

How would you break an existing monolith into services without a big-bang rewrite?
How do you keep an order and its payment consistent when they live in two services?
How do you change an API contract that three other services depend on?

What considerations would you take into account when designing a data storage solution?

Medium · System Design / Architecture

Approach

Start from access patterns: read/write ratio, query shapes (point lookups, range scans, aggregations, full-text search), data volume and growth rate, and latency targets; the storage choice follows from these, not from familiarity.
Match the model to the need: a relational database (PostgreSQL, MySQL) for joins, constraints and ACID transactions; a document store for flexible nested records; a wide-column store such as Cassandra for very high write throughput queried by partition key; a key-value store for sessions and caching; object storage for large files; a time-series database for timestamped measurements.
Plan scaling and its costs: vertical scaling first, read replicas (with replication lag, so reads can be stale), then sharding by a key, which brings cross-shard queries, hot keys and resharding pain; time-based partitioning for append-heavy data.
State the consistency choice: under a network partition a system favours consistency or availability; with quorum replication, R + W > N makes reads see the latest acknowledged write.
Cover durability and operations: backups with point-in-time recovery and tested restores, recovery point and recovery time objectives, retention policy, encryption at rest, access control, and cost tiers for hot versus archival data.

Follow-up

A user writes a record and a read replica immediately returns the old value. How do you give that user read-your-writes?
How would you pick a shard key for this data, and what makes a shard key bad?
How would you change the schema of a very large table without downtime?

Discuss how you would handle user authentication in a distributed system.

Medium · System Design / Architecture

Approach

Centralize identity in one auth service or identity provider issuing tokens through OAuth 2.0 and OpenID Connect; other services never handle passwords, and stored passwords are hashed with a salted slow hash such as bcrypt, scrypt or Argon2.
Choose the token model and state its trade-off: a signed JWT lets every service verify locally (signature, exp, iss, aud) with no lookup, but cannot be revoked before expiry; an opaque token checked against a session store such as Redis revokes instantly at the cost of a lookup per request.
Combine them in practice: short-lived access tokens plus longer-lived refresh tokens stored server-side and rotated on use, so a logout or ban takes effect within the access-token lifetime.
Sign with an asymmetric algorithm (RS256 or ES256) so services verify with a public key fetched from a JWKS endpoint and never hold the signing key; the kid header allows key rotation. Validate at the API gateway, pass identity claims downstream, and authenticate service-to-service calls with mTLS or client-credentials tokens.
Cover browser and abuse edges: HTTPS everywhere, tokens in HttpOnly, Secure, SameSite cookies to limit theft through XSS, CSRF protection for cookie auth, rate limiting and MFA on login, and a small clock-skew allowance when checking exp.

Follow-up

A user is banned. How do you stop their JWT from working before it expires?
How would you rotate the token signing key without logging everyone out?
How should internal services authenticate to one another?

Describe a system you designed and the trade-offs you considered.

Medium · System Design / Architecture

Approach

Pick a system whose design you owned or substantially shaped, and open with the problem and the constraints: load, latency target, data size, team size and deadline.
Sketch the architecture in order: clients, entry point, main services, data stores, queues and caches, and how a request or event flows through them.
Name two or three real trade-offs, each with the alternative you rejected and the constraint that decided it: relational versus NoSQL, synchronous call versus queue, strong versus eventual consistency, build versus buy.
Give measured outcomes (p99 latency, throughput, cost, incident count) and one thing that went wrong after launch and how you changed the design.
Finish with how the design would change at ten times the load; describing only the final system without the decisions behind it, or claiming decisions others made, undermines the answer.

Follow-up

Which design decision would you reverse with what you know now?
Where does this system hit its first bottleneck at ten times the load?
How did you validate the design before committing to build it?

You have a dataset with missing values. What approach would you take to handle this?

Medium · Problem-Solving / Case Studies

Approach

Quantify before acting: missing rate per column and per row, and whether missingness clusters by segment or time. Look for sentinel values such as -1, 0 or 9999 that a null check does not catch.
Classify the mechanism: missing completely at random (unrelated to any data), missing at random (explained by observed columns), or missing not at random (depends on the missing value itself); dropping rows is only safe under the first, and only when the fraction is small.
Pick the treatment per column: drop a column that is mostly empty and low value; impute numeric values with the median (robust to outliers) or mean, categorical values with the mode or an explicit 'missing' category; forward-fill or interpolate time series; use KNN or iterative (MICE-style) imputation when columns are correlated.
Add a missing-indicator feature where missingness itself may carry signal, and note that mean imputation shrinks variance and weakens correlations.
Prevent leakage: fit the imputer on the training split only and apply it to validation and test, for example with a scikit-learn Pipeline containing SimpleImputer; compare strategies by the downstream metric.

Follow-up

How would you check whether values are missing at random or not?
Why must the imputer be fitted only on the training data?
What changes if the data is a time series from a sensor that drops readings?

How would you evaluate the performance of a machine learning model?

Medium · Problem-Solving / Case Studies

Approach

Split correctly first: a held-out test set or k-fold cross-validation; stratify on the label for imbalanced classes, split by time for time-dependent data, and by group when the same entity appears in many rows, so the score is not inflated by leakage.
For classification, start from the confusion matrix: precision = TP / (TP + FP), recall = TP / (TP + FN), F1 as their harmonic mean; ROC-AUC is threshold-independent, while PR-AUC is more informative with rare positives. Accuracy misleads under imbalance: predicting all-negative on 99% negatives scores 99%.
For regression, report MAE and RMSE (RMSE penalizes large errors more heavily) and R-squared, and compare against a simple baseline such as predicting the mean or the last value.
Choose the operating threshold from the relative cost of false positives and false negatives, and check calibration with a reliability curve or Brier score if the probabilities are used directly.
Go beyond one number: error analysis by segment, a check that offline gains hold in an online A/B test, and monitoring for data and prediction drift after deployment.

Follow-up

A model scores 98% accuracy on data with 2% positives. Is it good?
How would you choose the decision threshold for this model?
Offline metrics improved but the production metric did not move. What would you check?

Describe your thought process when faced with a new and unfamiliar problem.

Medium · Problem-Solving / Case Studies

Approach

Restate the problem and define done: inputs, outputs, constraints and the success criterion, and ask the clarifying questions that change the solution.
Work a small concrete example by hand, then look for a known problem it reduces to (graph search, interval scheduling, sorting plus a scan, a sliding window).
Build the simplest correct solution first and state its complexity, then improve it by finding the repeated work it does.
For an unfamiliar domain, time-box the research: read the documentation or source, build a small throwaway prototype, ask someone who knows the domain, and write down assumptions so each can be tested.
Verify with tests that include edge cases, and give one real example of using this process with what it produced.

Follow-up

Walk me through a time you had to learn a new domain quickly. What did you read or build first?
How do you decide when to stop researching and start building?
How do you know your simple version is correct before you optimize it?

How do you balance speed of delivery with the quality of the solution?

Medium · Problem-Solving / Case Studies

Approach

Classify the change by reversibility and blast radius: reversible, low-risk work behind a feature flag can ship quickly; irreversible work such as data migrations, public API contracts, security and payments gets full rigour.
Name the parts that stay fixed under any deadline: tests on the core paths, code review, and no known data-loss bugs; when time is short, negotiate scope (a smaller first version) rather than dropping those.
Reduce the risk of shipping fast: staged rollouts or canaries, monitoring and alerts on the new path, and a tested rollback.
Make shortcuts explicit: a ticket with an owner and a date for each piece of debt taken on, so it is repaid rather than forgotten.
Support it with one concrete example: the deadline, what you cut, what you protected, and what happened after release.

Follow-up

Tell me about something you shipped that you were not happy with. What happened next?
How do you push back on a deadline you think is unrealistic?
How do you get time allocated to repay technical debt?

A client reports a bug in production. What steps do you take to troubleshoot?

Medium · Problem-Solving / Case Studies

Approach

Triage and scope: collect the client's details (account, timestamp, request ID, app version, exact steps), reproduce or confirm the symptom, decide severity from how many users are affected, and send the client a status update with the next checkpoint.
Mitigate before finding the root cause when impact is high: roll back the most recent deploy or switch the feature off with a flag.
Gather evidence: logs filtered by request or correlation ID, error-rate and latency dashboards, traces; then list what changed around the start time (deploys, config, dependency versions, data migrations, traffic patterns).
Narrow it down: reproduce in staging with the same data and configuration, and bisect the commits (git bisect) or the inputs until the cause is isolated; separate the trigger from the underlying defect.
Fix with a regression test, deploy, confirm with the client and the metrics, and follow up with a blameless postmortem and an alert that would have caught it earlier.

Follow-up

You cannot reproduce it locally or in staging. What do you do next?
The bug affects only one client. What would you suspect first?
How do you decide between rolling back and shipping a hotfix?

Suggested practice checklist

The plan follows the reported rounds: one day to map the loop and fix your language, two days of coding, a day of data and API questions, a design day, a problem-solving day and a day of behavioral stories. Each day ends with something you can check.

Day 1 — Map the loop and choose your language

Write the four reported rounds in order and list the question types each stage's reported format covers: coding, design, problem-solving scenarios and team collaboration.
Choose one language from Python, Java or C++ for every coding answer. Set up a file with a test harness you can reuse.
Write and say aloud your answer to "What programming languages are you most proficient in, and why?"

Deliverable: A one-page loop map, a working test harness in your chosen language, and a written answer on your language choice.

Day 2 — Core coding: linked list, binary search, unique characters

Reverse a linked list iteratively, then recursively. Test empty, one-node and long lists, and state time and space.
Implement binary search, then a lower-bound variant that returns the first matching index when there are duplicates.
Solve the unique-characters question three ways (hash set, sort, bitmask for lowercase letters) and compare their space and time.

Deliverable: Three tested functions with a complexity note for each.

Day 3 — Sorting complexity and dynamic programming

Write merge sort and quicksort. For each, record worst-case and average time, extra memory and whether it is stable, then say when you would pick each.
Choose one dynamic programming problem, such as coin change or longest common subsequence. Write the state, recurrence and base cases, then code top-down with memoization and bottom-up.
Explain out loud how you identified overlapping subproblems and how you would reduce the table's memory.

Deliverable: A sorting comparison table and a dynamic programming solution in two forms with its recurrence.

Day 4 — APIs, queries and data questions

Write a comparison of REST and SOAP covering message format, contract definition, statefulness, error handling and when each is a reasonable choice.
Write a checklist for speeding up a slow database query: read the query plan, check for a usable index, remove unneeded columns and joins, and re-measure.
Outline how you would handle missing values and how you would evaluate a model, naming the metrics you would use for balanced and imbalanced labels.

Deliverable: A REST versus SOAP table, a query tuning checklist and two short outlines for the data and model questions.

Day 5 — System design drills

Design a URL shortening service on paper: key generation, storage, cache, redirect path, expiry and how it scales when traffic grows tenfold.
Design authentication for a distributed system: sessions versus tokens, where tokens are verified, revocation and password storage.
Write what you would consider when choosing a data store, and how you would split an application into microservices and where you would not.

Deliverable: Three design outlines and a list of trade-offs you can reuse, including a one-minute account of a system you built yourself.

Day 6 — Problem-solving and engineering practice

Rehearse a production-bug walkthrough aloud: reproduce, check recent changes, read logs and metrics, narrow down, fix, add a regression test.
Prepare answers on unfamiliar problems and on balancing speed with quality, each with a real example from your work.
Write your account of a hard technical problem and of how you keep code maintainable.

Deliverable: Four spoken answers recorded and checked for assumptions, structure and a concrete example.

Day 7 — Behavioral stories and a full run-through

Write five stories in situation, action, result form and match each to conflict, prioritization, leading, feedback or motivation.
Practise each answer aloud and cut anything that is not your own decision.
Run one mock session: a coding problem from days 2-3, a design question from day 5, then two behavioral questions.

Deliverable: Five written stories and one complete mock run.

Behavioural preparation

Candidates describe collaboration and communication as an evaluation area, including team dynamics, taking feedback and explaining technical points to non-technical colleagues, and Final Interviews are reported to cover team collaboration. These prompts test whether you can tell a specific story with your own decisions and a visible result.

How do you balance speed of delivery with the quality of the solution?

Describe a time when you had to deal with a conflict within your team. How did you handle it?

Medium · Behavioral / Leadership

Approach

Choose a conflict with real substance, such as a disagreement over a technical approach, ownership of a component or a review standard, where you took an active part in resolving it. Skip a story where a manager settled it for you.
Give the situation in two sentences, then spend most of the answer on your actions: you asked the other person to explain their reasoning, restated it to confirm you understood, and agreed on a shared way to decide, such as a small benchmark, a spike or a written comparison of options.
State the outcome and the working relationship afterwards. Include what you conceded, since a story where you were simply right reads as one-sided.
Avoid blaming a person or describing them as difficult. Describe the disagreement as a disagreement over a decision, and end with what you do differently now when you see a conflict forming.

Follow-up

What if the other person still disagreed after you shared the evidence?
What did you concede, and was that the right call?
How do you handle a disagreement with someone more senior than you?

How do you prioritize tasks when working on multiple projects?

Medium · Behavioral / Leadership

Approach

Give your actual method rather than a tool name: list the tasks, note the deadline and who is waiting on each, estimate the cost of a delay, and do blocking or time-critical work first. A production incident outranks planned feature work.
Anchor it in a real period when you had several projects at once. Name the projects, say what you moved to the front and what you pushed back, and give the reason for each.
Describe how you communicated the trade-off. Tell the owner of the delayed item early, with a new date or a smaller scope, rather than letting it slip silently.
Show you can say no or renegotiate scope, and that you revisit the order when something changes, such as a new urgent request or a dependency becoming unblocked.
Avoid answers that only describe a task list or calendar habit with no decision in them.

Follow-up

Two managers give you conflicting top priorities. What do you do?
What did you drop, and how did its owner react?
How do you handle an incident that interrupts planned work?

Can you give an example of how you led a project or initiative?

Medium · Behavioral / Leadership

Approach

Pick an initiative where you owned the outcome, even without a manager title: a migration, a new service, a testing effort or a release. State its goal and what success meant before describing the work.
Cover the leadership actions: how you broke the work into pieces, who took which piece, how you tracked risks and how you kept people aligned, for example with a short design note, regular check-ins and clear milestones.
Describe one hard moment, such as a teammate who did not agree with the plan or a deadline that moved, and what you decided.
End with a result you can check, such as latency, error rate, time saved or adoption, and one thing you would change.
Use "I" for your decisions and name teammates for theirs. A story told only in "we" hides your contribution.

Follow-up

How did you handle a teammate who did not buy into the plan?
What would you have cut if the deadline had been moved up?
How did you measure whether the initiative worked?

Tell me about a time you received constructive feedback. How did you respond?

Medium · Behavioral / Leadership

Approach

Choose feedback that was specific and a little uncomfortable, such as review comments about missing tests, unclear pull request descriptions or how you ran a design discussion. Do not choose a weakness that is secretly a strength.
Describe your first reaction honestly, then what you did: asked for a concrete example, checked whether the pattern was real, and agreed on what better looks like with the person who gave it.
Show the change as something repeatable, for example a checklist, a habit in how you write pull requests, or a different way of preparing for meetings.
Give evidence that it stuck: later review comments changed, a teammate noticed, or the same mistake stopped recurring.
Do not argue with the feedback in the retelling or present yourself as flawless.

Follow-up

Was there feedback you disagreed with, and what did you do?
How do you give difficult feedback to a peer?
What feedback are you working on now?

What motivates you to perform at your best?

Medium · Behavioral / Leadership

Approach

Name one or two real drivers and prove each with a moment from your work, such as the satisfaction of tracking down a hard bug, seeing users rely on something you shipped, or helping a teammate get unblocked.
Link the driver to how you behave at work: what you pick up first, how you handle repetitive tasks, and what you do when the work gets hard.
Connect it to the role honestly. The role description mentions cross-functional teams and projects across robotics, optics and biomaterials, so say what about working that way or on that kind of problem interests you only if it is true for you. Do not claim knowledge of Becoming's values.
Avoid generic answers such as money or passion with no example. A short account of what drains you and how you manage it makes the answer more credible.

Follow-up

What drains your motivation, and what do you do about it?
Tell me about a time your motivation was low. What changed it?
How does what motivates you show up when you work in a team?