The reported loop is broad rather than deep in any one area. The topic areas candidates list are data structures and algorithms, SQL, DBMS, operating systems and computer networks, and the reported questions mix them: string reversal, binary search, FizzBuzz and array intersection on the coding side, SQL versus NoSQL and slow-query tuning on the database side, and object-oriented principles, REST, exception handling and synchronous versus asynchronous code as language and API fundamentals. Because the questions are fundamentals, a clear, correct, example-backed answer matters more than an obscure trick.
The system design questions all circle an online store: a scalable e-commerce platform, storage and retrieval under heavy traffic, microservices versus a monolith, and a design for peak sales. Prepare one reusable skeleton for them: separate the read-heavy catalog and search path from the write-heavy cart, checkout and inventory path, decide where caching is safe, and say which data must be strongly consistent (stock and payment) and which may be stale (product listings, counts). The same skeleton answers all four.
The role description mentions code reviews, sprint planning, retrospectives and work with product managers and UX designers, and the reported behavioral questions line up with that: a difficult team member, juggling several projects, learning a technology fast, and handling feedback. Plan to arrive with five or six real stories, each with a decision you made, a result you can measure, and something you changed afterwards.
The stack candidates list is wide: JavaScript, Python or Java, React, Angular, Node.js, MySQL, MongoDB and Git. You do not need all of it. Choose one language for the coding rounds and know it cold, then be able to talk through one relational and one document database, since the SQL versus NoSQL question invites exactly that comparison.
HR Screen
reportedCandidates report an initial screen that looks at your background and fit for the role. No technical topics are reported for this stage. Treat it as the place to present your experience in a way that lines up with the stack listed for the role (JavaScript, Python or Java, React or Angular, Node.js, MySQL or MongoDB, Git) and to learn how the later rounds work.
What to demonstrate
- Your background and fit for the role, as the stage is described
- How clearly you summarise projects and the technologies you used in them
How to prepare
- Write a short career narrative that ends at e-commerce or web-platform work you have done, and name the one project you would expand on if asked.
- Match each item in the listed stack to a project or a piece of coursework, and note honestly which items are new to you.
- Prepare two questions about the role and one about what the Coding Skills Demonstration involves, since its format is not reported in detail.
- Have your availability, location and notice period ready so the logistics do not take up the call.
Technical Interviews
reportedCandidates report technical interviews that may include coding assessments and system design questions. Across the loop, the topic areas candidates list are data structures and algorithms, SQL, DBMS, operating systems and networks, so prepare for fundamentals across all of them rather than one deep specialty. Work through the reported fundamentals out loud: object-oriented principles, SQL versus NoSQL, REST, exception handling and synchronous versus asynchronous code.
What to demonstrate
- Command of core technical concepts across the listed topic areas
- Working coding ability where a coding assessment is part of the stage
- Ability to sketch a design for an e-commerce workload where design questions come up
How to prepare
- Write a one-page answer for each reported fundamental: the four object-oriented principles with a cart or order example, SQL versus NoSQL with a concrete schema in MySQL and a document in MongoDB, and the parts of a REST API (resources, verbs, status codes, statelessness).
- Practise the peak-sales design question until you can lay out the read path, the write path, caching and inventory consistency without notes.
- Review the database basics that sit under SQL questions: indexes, joins, transactions and isolation.
- Refresh processes versus threads and the basics of HTTP and TCP, since operating systems and networks are in the reported topic list.
Coding Skills Demonstration
reportedCandidates report a Coding Skills Demonstration in which you show your coding through practical exercises. The reported coding questions are short classics: reverse a string, implement binary search, solve FizzBuzz, and find the intersection of two arrays. Expect to write real, runnable code in a language you choose, and to explain it as you go.
What to demonstrate
- Working code that handles ordinary and edge-case input
- Choice of data structure and its time and space cost
- How clearly you explain what you are writing
How to prepare
- Write all four reported coding problems in your chosen language from a blank file, then add tests for empty input, a single element, duplicates and very large input.
- For binary search, practise the loop invariant (lo <= hi, mid computed without overflow) and the variants: first occurrence, insertion point, and rotated input.
- For array intersection, write both the hash-set version and the sorted two-pointer version and state when each wins.
- Practise narrating while typing: state the approach, then the complexity, then code, then test with a trace.
Problem-Solving Discussions
reportedCandidates report Problem-Solving Discussions about your technical background and how you approach problems. The reported questions that fit this format include debugging a production issue, prioritising a user-reported bug, optimising a slow SQL query, and describing a technical challenge you resolved. Bring a structured method and two or three real projects you can discuss in depth.
What to demonstrate
- How you break a vague problem into steps and reason about it aloud
- Depth of understanding of projects you list on your CV
How to prepare
- Prepare a repeatable debugging sequence: reproduce, check recent changes, read logs and metrics, bisect, fix, add a regression test, then write up the cause.
- Write a bug-triage rule you can state in one breath, built from user impact, number of users affected, whether a workaround exists, and risk of the fix.
- Pick two past projects and be able to explain the architecture, one decision you would reverse, and how you measured the result.
- Run PracHub's practice scenario on a p99 jump on one listing filter while p50 stayed flat, to rehearse a measurement-first debugging narrative.
PracHub editorial advice for the preparation topics above.
Reciting the four object-oriented principles as definitions with no example
Attach each principle to code you could write on the spot, for instance a payment interface with card and wallet implementations for polymorphism, and a class that hides its internal totals for encapsulation. Be ready to say when inheritance is the wrong choice and composition is better.
Writing binary search with an off-by-one error or an endless loop, then not testing it
State the invariant (the target is within lo..hi), compute mid as lo + (hi - lo) / 2, and trace three inputs by hand: empty array, one element, and a target that is missing. Do the same trace for the string reversal and array intersection functions, including duplicates.
Answering the slow-query question with "add an index" and nothing else
Start from the execution plan (EXPLAIN): look for full scans, bad join order and sorts. Then check that predicates are sargable (no function wrapped around an indexed column), that the index matches the filter and sort columns, and that you select only needed columns. Re-measure after each change.
Treating the peak-sales design as "add more servers"
Separate the browse path from the checkout path. Put a CDN and cache in front of the catalog, queue or rate-limit write spikes, and protect stock counts with a transactional decrement so the store cannot oversell. State what may be stale and what may not.
Behavioral answers that blame a colleague or say "we" for everything
Write each story in first person: the decision you made, the evidence you used, the result, and what you changed afterwards. Remove any sentence that only describes the other person's flaws.
Choose a category, try a prompt, then open its approach, worked solution or follow-up when you need it.
What is the difference between synchronous and asynchronous programming?
What is the difference between synchronous and asynchronous programming?
Approach
- Define the difference. A synchronous call blocks the caller until the result is ready. An asynchronous call starts the work and returns at once, and the result arrives later through a callback, promise/future or await.
- Explain the runtime model. Node.js runs JavaScript on one thread with an event loop, and libuv's thread pool handles some work (fs, dns.lookup, parts of crypto and zlib). Async helps I/O-bound work, but a CPU-heavy loop blocks every request until it finishes (move it to worker_threads).
- Show it in code: sequential awaits add up latency, while Promise.all runs independent calls concurrently and rejects on the first failure. Promise.allSettled collects every outcome. Wrap await in try/catch so no rejection goes unhandled.
- Separate async from multithreading. Python asyncio is concurrency on one thread, so a blocking call like time.sleep or requests.get inside a coroutine stalls the whole loop (use asyncio.sleep, an async client or run_in_executor). Java uses threads or CompletableFuture.
Follow-up
- What happens to other requests when one Node.js handler runs a long CPU loop?
- Compare three sequential awaits with Promise.all on the same calls, in latency and error behaviour.
- How is asynchronous programming different from multithreading?
Write a function that reverses a string.
Write a function that reverses a string.
Approach
- Clarify the language and whether to reverse in place. Strings are immutable in Python and Java, so the answer returns a new string: s[::-1] in Python, new StringBuilder(s).reverse().toString() in Java. Both are O(n) time and O(n) space.
- Write the manual version with two pointers on a character array: i = 0, j = n - 1, swap and move inward while i < j. That is O(n) time and O(1) extra space beyond the array.
- Avoid building the result by repeated concatenation in a loop. In languages that copy on every concatenation it becomes O(n^2), so use a list and join, or a builder.
- Raise Unicode. JavaScript's s.split('').reverse().join('') breaks surrogate pairs such as emoji. [...s] keeps code points intact but still splits combined graphemes (accents, ZWJ emoji), which need Intl.Segmenter. Java's StringBuilder.reverse keeps surrogate pairs together. Test empty, single-character, odd and even lengths.
Follow-up
- Reverse the order of the words in a sentence without reversing the letters.
- Write it recursively. What limits the input size (Python's default recursion limit is 1000)?
- Check whether a string is a palindrome, ignoring case and non-alphanumeric characters.
Explain how you would implement a binary search algorithm.
Explain how you would implement a binary search algorithm.
Approach
- State the precondition: the array is sorted, or more generally the predicate is monotonic. The search is O(log n) time, O(1) space iteratively and O(log n) stack space recursively.
- Write the closed-interval version: lo = 0, hi = n - 1, loop while lo <= hi, mid = lo + (hi - lo) / 2 (avoids the integer overflow of (lo + hi) / 2 in Java and C++), then return mid, set lo = mid + 1 or set hi = mid - 1. Return -1 when the loop ends.
- Give the lower-bound variant for duplicates and insertion points: half-open [lo, hi) with hi = n, loop while lo < hi, set lo = mid + 1 if a[mid] < target, else hi = mid. It matches Python's bisect_left, and bisect_right finds the end of a run.
- Cover edge cases: empty array, one element, target below the first or above the last value, and all elements equal. Point out the infinite-loop bug when lo = mid is used with a floor mid.
- Mention binary search on the answer: when feasible(x) is monotonic (the minimum ship capacity that finishes in D days), search over x instead of an array index.
Follow-up
- Find the first and last position of a target in a sorted array with duplicates.
- Search a rotated sorted array in O(log n).
- How would you find the square root of an integer, rounded down, without a library call?
Can you solve the FizzBuzz problem?
Can you solve the FizzBuzz problem?
Approach
- Clarify the output: print, or return a list of strings, and what happens for n <= 0 (empty output). Loop i from 1 to n inclusive in O(n).
- Check the combined case first: if i % 15 == 0 output FizzBuzz, then i % 3 for Fizz, then i % 5 for Buzz, else str(i). Checking 3 before 15 is the classic ordering bug.
- Show a version that extends: build the word by appending Fizz when i % 3 == 0 and Buzz when i % 5 == 0, and fall back to the number when it is empty. Or drive it from an ordered list of (divisor, word) pairs so a new rule is one entry.
- Test it: 1, 3, 5, 15 and n = 0, with a unit test that compares the first 15 outputs to the expected list.
Follow-up
- Add a rule that 7 prints Bazz without editing the existing branches.
- Write it without the modulo operator.
- How would you unit test it if it printed instead of returning a list?
Write a function to find the intersection of two arrays.
Write a function to find the intersection of two arrays.
Approach
- Clarify the contract: unique values only, or with multiplicity (each match counted as often as it appears in both), whether output order matters, and whether the inputs are sorted.
- Unique values: put the smaller array in a hash set and scan the larger one, adding matches to a result set. That is O(n + m) expected time and O(min(n, m)) extra space.
- With multiplicity: count the smaller array in a hash map (Counter in Python). For each element of the other array with a positive count, emit it and decrement.
- If both arrays are sorted, walk two pointers and advance the smaller value: O(n + m) time, O(1) extra space. If one array is tiny and the other is large and sorted, binary-search each small element for O(k log n). Mention the nested-loop O(n * m) baseline, and test empty arrays, duplicates and negatives.
Follow-up
- One array is too large for memory and sits on disk. How do you intersect them?
- Both inputs are already sorted. Which approach do you pick and why?
- How do you intersect k arrays efficiently?
What are the differences between SQL and NoSQL databases?
What are the differences between SQL and NoSQL databases?
Approach
- Compare data models first. Relational stores (MySQL, PostgreSQL) use tables with a schema enforced on write and joins across them. NoSQL covers document (MongoDB), key-value, wide-column and graph stores, usually with a flexible schema shaped by access patterns.
- Compare transactions and consistency. Relational databases give multi-row ACID transactions by default. Many NoSQL stores favour availability and partition tolerance with eventual consistency, though MongoDB has supported multi-document transactions since 4.0 (replica sets) and 4.2 (sharded clusters).
- Compare scaling. Relational systems usually scale up and add read replicas, and sharding takes extra work. Many NoSQL stores partition horizontally by key, and the cost is expensive cross-partition queries and few or no joins.
- Pick per workload: orders and payments in a relational store for integrity, a catalog where a ring and a necklace carry different attribute sets as documents, sessions or carts in a key-value store. Say the choice is per data set, not per company.
Follow-up
- Would you embed order items inside the order document in MongoDB or reference them, and why?
- What does the CAP theorem say a store must give up during a network partition?
- When does denormalising data for read speed start to hurt?
How would you optimize a slow-running SQL query?
How would you optimize a slow-running SQL query?
Approach
- Measure before changing anything. Find the query in the slow query log or monitoring, then read its actual plan with EXPLAIN ANALYZE (PostgreSQL, or MySQL 8.0.18+). Look for full scans, the node with the most time, and estimated vs actual row counts that are far apart.
- Fix indexing. Build a composite index with equality columns first and then the range or ORDER BY column, and make it covering where that avoids table lookups. Keep predicates sargable: WHERE DATE(created_at) = ..., a leading-wildcard LIKE '%x' or an implicit type cast stops the index being used, so rewrite them as ranges.
- Fix the query shape. Select only the needed columns, replace a correlated subquery with a join or EXISTS, aggregate before a join that fans rows out, and swap deep OFFSET pagination for keyset (WHERE id > last_id ORDER BY id LIMIT n).
- Check what sits around the query: stale statistics (run ANALYZE), lock waits, and ORM N+1 patterns that send many small queries. Verify on production-sized data and weigh each new index against slower writes and extra storage.
Follow-up
- You added an index and the planner still does a full scan. What are the likely reasons?
- Can an index on (a, b) serve a query that filters only on b?
- When would you cache or denormalise instead of tuning the query further?
Explain the principles of Object-Oriented Programming.
Explain the principles of Object-Oriented Programming.
Approach
- Name the four principles and tie each to one class: encapsulation (a Product keeps price private and changes it only through a method that validates discounts), abstraction (callers see applyDiscount(), not the arithmetic), inheritance and polymorphism.
- Show polymorphism as runtime dispatch: a PaymentMethod interface with charge() implemented by CardPayment and GiftCardPayment, so checkout code calls charge() with no type checks. Separate it from overloading, which is resolved at compile time in Java.
- Give the inheritance trade-off: use it only for a true is-a relation that honours the base contract (Liskov; Square extending Rectangle breaks setWidth). Prefer composition when behaviour varies independently, because deep hierarchies create fragile base classes.
- Mention language differences: Java allows single class inheritance plus multiple interfaces, Python allows multiple inheritance resolved by the C3 method resolution order, and JavaScript classes are syntax over prototype chains.
Follow-up
- Refactor an inheritance hierarchy into composition and explain what you gained.
- What is the difference between an abstract class and an interface in Java?
- How does Python decide which method runs when two parent classes define it?
Can you describe a RESTful API and its components?
Can you describe a RESTful API and its components?
Approach
- Define REST through its constraints: client-server, stateless requests, cacheable responses, a uniform interface and resources identified by URIs (nouns such as /orders/{id}/items), exchanged as representations like JSON.
- Map methods to semantics. GET is safe and idempotent, PUT replaces the whole resource and is idempotent, PATCH applies a partial update, POST creates and is not idempotent, DELETE is idempotent.
- List the components a request carries: method, URI, headers (Authorization, Content-Type, Cache-Control, ETag with If-None-Match returning 304), body and status code. Use 201 with Location on create, 204, 400, 401 for unauthenticated vs 403 for forbidden, 404, 409, 429 and 5xx.
- Cover the operational parts: versioning (/v1 path or a header), cursor pagination for large lists, and an Idempotency-Key header so a retried POST that creates an order or charge does not apply twice. HATEOAS is the constraint most APIs skip.
Follow-up
- How do you make a POST that creates an order safe to retry after a client timeout?
- Offset or cursor pagination for a large product listing: what breaks with each?
- When would you use PUT rather than PATCH?
Given a scenario where a user reports a bug, how would you prioritize fixing it?
Given a scenario where a user reports a bug, how would you prioritize fixing it?
Approach
- Size the impact first: how many users, which flow (checkout or payment failures vs a cosmetic issue), whether data is lost or exposed, and whether a workaround exists. Treat severity (how bad) and priority (how soon) as separate calls.
- Reproduce it. Collect steps, browser and device, account and timestamp, then check error tracking, logs and recent deploys. If it started with a release, compare versions or bisect commits to find the change.
- Decide the response. If revenue, data or security is hit, roll back or turn off the feature flag first and fix forward afterwards. Otherwise file a ticket with repro steps and a priority, schedule it, and tell the reporter what happens next.
- Close it properly. Write a regression test that fails before the fix and passes after it, watch the error rate after deploy, and for a severe bug write a short root-cause note so the same class of bug gets caught earlier.
Follow-up
- A checkout error for a small share of users and a wrong image for every user arrive together. Which do you fix first?
- You cannot reproduce the bug. What do you do next?
- When do you roll back rather than fix forward?
Explain how you would design a system to handle high traffic during peak sales.
Explain how you would design a system to handle high traffic during peak sales.
Approach
- Estimate the load: peak requests per second against baseline and the read/write mix. Browsing dominates, and checkout writes are fewer but matter most. Set latency and error targets for each path.
- Read path: serve images and static assets from a CDN, cache product and price data (Redis, TTL plus invalidation on change), add read replicas, and run stateless app servers behind a load balancer. Scale out before a known sale, because autoscaling reacts with a delay.
- Write path: prevent overselling with a conditional decrement (UPDATE ... SET stock = stock - 1 WHERE id = ? AND stock >= 1) or time-limited reservations. Use idempotency keys on payment calls and move email and fulfilment onto a queue.
- Protect the system: rate limits, timeouts and circuit breakers around the payment provider, load shedding, turning off non-essential features such as recommendations, and a waiting-room queue for flash sales.
- Prove it beforehand with a load test on a realistic traffic mix. Add dashboards for p99 latency, error rate and queue depth, plus a rollback plan and a change freeze for the event.
Follow-up
- One popular item gets thousands of purchase attempts a second. How do you handle contention on its inventory row?
- A hot cache key expires at peak. How do you prevent a stampede on the database?
- The payment provider slows to several seconds per call. What happens to your app servers, and how do you contain it?
How would you design a scalable e-commerce platform?
How would you design a scalable e-commerce platform?
Approach
- Scope the requirements: catalog browsing and search, product detail, cart, checkout, payment, order history and inventory. Browsing must stay available under load, while inventory and payment need strong consistency.
- Lay out the components: CDN and object storage for images, a load balancer or API gateway, stateless services for catalog, search (an Elasticsearch/OpenSearch index fed from catalog change events), cart (key-value store keyed by user or session) and orders (relational database with transactions).
- Walk through checkout: reserve inventory, create the order as PENDING, call the payment provider with an idempotency key, then mark it CONFIRMED or release the reservation on failure. Use a transactional outbox so the order row and its event commit together, then publish to a queue for email and fulfilment.
- Scale and justify: cache product pages and prices, add read replicas, and partition orders by order or user id when one database is no longer enough. Starting as a modular monolith and splitting services as load and team size demand it is a defensible choice.
Follow-up
- How do you keep the search index consistent with a price change?
- The payment succeeded but writing the order failed. How does the system recover?
- How do you merge a guest cart into a user's cart at login?
What considerations would you make for data storage and retrieval in a high-traffic application?
What considerations would you make for data storage and retrieval in a high-traffic application?
Approach
- Start from access patterns: read/write ratio, key lookups vs range scans vs full-text search, latency target, growth rate, and the consistency each data set needs (inventory vs reviews vs session data).
- Caching: use cache-aside with TTLs, invalidate or update on write, add jitter to TTLs and coalesce requests to avoid stampedes, and track the hit ratio. Serve blobs from object storage behind a CDN, not the database.
- Database reads: index for the real queries, use keyset pagination, pool connections (for example PgBouncer), and add read replicas. Handle replication lag by routing a user's reads to the primary right after their own write (read-your-writes).
- Scale writes by partitioning. Choose a shard key that spreads load evenly, say which queries become cross-shard, and plan for hot keys. Keep analytics off the transactional database by sending it to a separate store.
Follow-up
- A user edits their address and the reload shows the old one. What happened and how do you fix it?
- Pick a shard key for an orders table and name the query it makes expensive.
- Cache-aside or write-through: when do you choose each?
Explain the trade-offs between microservices and monolithic architecture.
Explain the trade-offs between microservices and monolithic architecture.
Approach
- Monolith: one deployable, in-process calls, a single database transaction across modules, simple local debugging and operations. The costs are coupled releases, scaling the whole app for one hot path, and coordination in a large shared codebase.
- Microservices: independent deploys and scaling, clear team ownership, fault isolation and technology choice per service. The costs are network latency and partial failures, no cross-service ACID transaction (sagas with compensating actions), distributed tracing, and more infrastructure for discovery and per-service CI/CD.
- Decide on concrete factors: number of teams, how stable the domain boundaries are, and whether one component has a very different scaling or release profile (search or image processing). A modular monolith with enforced module boundaries is the usual middle path.
- Name the failure mode: a distributed monolith, where services share one database or must deploy in lockstep, pays both sets of costs. Migrate gradually with the strangler fig pattern, extracting one bounded context at a time.
Follow-up
- How do you place an order that must update both an order service and an inventory service?
- What would you extract first from a monolith, and how would you route traffic during the cutover?
- How do you debug a slow request that crosses five services?
p99 jumped on one listing filter while p50 stayed flat
After a release that added an owner_user_id filter to the resource listing, p99 rose from 90 ms to 1.9 s while p50 stayed at 40 ms. Traffic and row counts are unchanged. resource carries the index (tenant_id, status, updated_at DESC, resource_id DESC). The new query filters tenant_id and owner_user_id, orders by updated_at DESC, resource_id DESC, and takes 20 rows. On PostgreSQL, explain the shape of the regression, prove it from a query plan, and give the index you would add.
Approach
- Start from the shape. A flat p50 with a moved p99 means a subset of requests changed cost, not all of them, so the first job is naming the subset. Bucket the endpoint's latency by the tenant's row count; the natural hypothesis is that large tenants are a small share of requests and all of the tail.
- Get the plan for the new query on a large tenant with EXPLAIN (ANALYZE, BUFFERS). Expect an index scan over the tenant's range, a filter discarding most of it, then a Sort feeding the Limit, possibly reporting Sort Method: external merge Disk. Read actual rows on the scan node, not estimated.
- Explain why the existing index cannot serve it. A composite B-tree is seekable only as a left prefix, and with no equality predicate on status the scan cannot treat updated_at as an ordering, because rows in the tenant's range are ordered by status first. Everything matching must be read and sorted before LIMIT 20 can apply, so a tenant with 400,000 rows pays 400,000 rows to return 20.
- Add (tenant_id, owner_user_id, updated_at DESC, resource_id DESC). Equality on the first two columns leaves the index ordered by updated_at within that pair, so the plan becomes an index scan that stops after 20 rows with no Sort node. PostgreSQL can scan a B-tree backwards, so the DESC markers matter only if the two sort columns ever disagree in direction; keeping them explicit documents the order the keyset cursor depends on.
Follow-up
- The endpoint paginates with OFFSET. What does page 500 cost with your index, and what does the keyset version cost?
- How would you have caught this before release, given that a 10,000-row seed database produces the same plan shape at an unnoticeable cost?
The plan follows the four reported rounds and the topic areas candidates list: coding fundamentals, SQL and databases, language and API concepts, e-commerce design, debugging, then behavioral stories and a full mock run. Each day produces something you can check.
Prepare, practise & reflect
One practical outcome each day. Spend longer where you need it.
0 / 7 done01Map the loop and the stack
- Write the four reported rounds (HR Screen, Technical Interviews, Coding Skills Demonstration, Problem-Solving Discussions) and, under each, the question types you expect to practise.
- Build a grid of the listed stack (JavaScript, Python or Java, React or Angular, Node.js, MySQL, MongoDB, Git) against your own projects, and mark the weak spots.
- Choose one language for all coding practice and write your career narrative for the HR Screen.
Deliverable: A round map, a stack-versus-projects grid with weak spots marked, and a written career narrative.
02Coding fundamentals
- Write string reversal, FizzBuzz, binary search and array intersection from a blank file in your chosen language.
- For binary search, also write the first-occurrence and insertion-point variants and trace the loop invariant.
- For array intersection, write the hash-set version and the sorted two-pointer version, and handle duplicates both ways (set semantics and multiset semantics).
- Add tests for empty input, one element, duplicates and very large input.
Deliverable: Four working functions with a test file covering empty, single, duplicate and large cases, and a note of each one's time and space cost.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗03SQL, DBMS and NoSQL
- Create an orders, order items and products schema in MySQL, write a revenue-per-product query, and run EXPLAIN before and after adding a suitable index.
- Rewrite a deliberately slow query (function on an indexed column, SELECT *, unneeded sort) and record what changed in the plan.
- Write a one-page comparison of SQL and NoSQL covering schema, joins, transactions, scaling and a MongoDB document for the same order.
- Review transactions, ACID and isolation levels well enough to explain a lost update.
Deliverable: A schema with before-and-after query plans, a one-page SQL versus NoSQL comparison, and a short note on transactions and isolation.
Practice prompt ↗Practice prompt ↗04OOP, REST, async and exceptions
- Write a small shopping cart in your language that shows encapsulation, inheritance versus composition, polymorphism and abstraction.
- Outline a REST API for products and orders: resources, verbs, status codes, idempotency of PUT and DELETE, pagination and error body.
- Write the same I/O task synchronously and asynchronously (callbacks, promises or threads) and explain what blocks and what does not.
- Write your answer on exception handling with one example of translating a failure into an API error.
Deliverable: A cart code sample, a one-page REST contract, a sync and async code pair with notes, and a written exception-handling answer.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗05E-commerce system design
- Sketch the peak-sales design: CDN, cache, load balancer, stateless services, queue for order writes and a transactional inventory update.
- Sketch the full e-commerce platform: catalog, search, cart, checkout, payments, orders and inventory, with the data store you would pick for each and why.
- Write the storage and retrieval considerations for heavy traffic: read replicas, caching with invalidation, indexes, partitioning and what you accept as stale.
- Write a monolith versus microservices comparison for a small team versus a large one, covering deployment, data ownership and failure modes.
Deliverable: Two labelled design diagrams (peak sales and full platform) and a one-page monolith versus microservices comparison, each with the consistency decisions written out.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗06Debugging, prioritisation and OS and network refresh
- Write a bug-triage rule using impact, number of users affected, workaround and fix risk, and apply it to three invented bug reports.
- Work PracHub's practice scenario on a p99 jump on one listing filter while p50 stayed flat, and write your debugging sequence.
- Review processes versus threads, deadlock conditions, the HTTP request lifecycle and the TCP handshake, then write five flash questions for yourself.
- Re-run one earlier coding problem under a time limit.
Deliverable: A triage rule with three worked cases, a written debugging sequence for the practice scenario and five OS and network flash questions with answers.
Practice prompt ↗Practice prompt ↗07Behavioral stories and a full mock run
- Write first-person stories for the technical challenge, difficult team member, prioritisation, quick learning and feedback questions, each with a result and a lesson.
- Say each story aloud and cut anything that describes someone else's flaws or hides your own role.
- Run a mock loop: a career summary, one coding problem, one SQL question, one design question and two behavioral answers, without notes.
- List your three weakest answers and fix them.
Deliverable: Five written stories, a recorded or timed mock run, and a short list of the three answers to fix.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Expand any day for tasks and deliverables. Your progress is saved on this device.
The behavioral questions candidates report cover conflict with a teammate, juggling several projects, learning a technology quickly, handling feedback and describing a technical challenge. The role description also mentions code reviews, sprint planning and work with product managers and UX designers, so stories set in reviews, planning and cross-team work fit naturally. Each story should show a decision you made, the evidence you used and what you changed afterwards.
How do you handle exceptions in your code?
How do you handle exceptions in your code?
Approach
- Treat it as a question about layers. Expected failures (invalid input, not found, payment declined) are modelled as return values or specific exception types and handled where the caller can act; unexpected failures (bugs, broken invariants) propagate up to a boundary rather than being silently absorbed.
- Catch the narrowest exception type you can handle, never a bare catch-all in the middle of business logic. Add context when rethrowing and keep the original cause (chained exceptions in Java and Python, the cause option on Error in JavaScript), so the stack trace survives.
- Release resources deterministically: try-with-resources in Java, with in Python, finally in JavaScript. Describe the boundary behaviour: an API layer translates exceptions into the right status code (400 for bad input, 404, 409, 500) with a stable error body, and logs once with a correlation id instead of at every layer.
- Cover async code: in JavaScript, await inside try/catch or a catch on the promise chain, so a rejected promise is never left unhandled. Retry only idempotent operations with backoff and a cap, and fail fast otherwise.
- Anchor it in one real example from your own code, such as a failed payment or inventory call in a checkout flow: what was caught, what the user saw, what was logged, and what you changed after an incident.
Follow-up
- When is it right to let an exception crash the request or the process?
- How do you handle errors in asynchronous code, and what happens to an unhandled rejection?
- What is the difference between checked and unchecked exceptions, and how would you design the error types for a public API?
Describe a time when you encountered a technical challenge. How did you resolve it?
Describe a time when you encountered a technical challenge. How did you resolve it?
Approach
- Pick a challenge where you did the technical work: a performance regression, a flaky test, a data inconsistency, an integration that failed under load. A challenge that was only hard because of a deadline gives you nothing technical to say.
- Structure it as situation, task, actions, result, and spend most of the time on actions: how you reproduced the problem, what you measured, the hypotheses you ruled out, and the options you weighed before choosing one.
- Give the evidence. Name the metric or symptom before and after (latency, error rate, query time, failed builds), using real figures from your own project, and say how you knew the fix caused the improvement.
- Close with what you learned or changed afterwards, such as a regression test, an alert, or a note in the runbook. A story with no follow-through reads as luck.
- The mistake that sinks it is a vague answer ("it was complicated, we worked hard and fixed it") or saying "we" throughout so your own contribution cannot be separated.
Follow-up
- What alternatives did you consider, and why did you reject them?
- How did you confirm the root cause rather than a symptom?
- What would you do differently if the same problem came up again?
Tell me about a time you had to work with a difficult team member.
Tell me about a time you had to work with a difficult team member.
Approach
- Choose a real disagreement over work, such as repeated code review conflict, missed handoffs, or a teammate who dismissed UX or product input, and describe the behaviour and its effect on the work, not the person's character.
- Show that you spoke to the person directly and privately first, asked about their view and constraints, and listened enough to restate their position before giving yours.
- Describe the concrete working agreement you reached: a review checklist, a shared definition of done, clearer ownership, a short sync. Then say whether it held, and what you did when it did not.
- Escalate only after direct attempts, and say what you brought to your manager: facts and a proposal, not a complaint.
- The mistakes that sink this answer are blaming the colleague, describing avoidance as patience, or a story with no resolution. Finish with the outcome for the project and for the relationship.
Follow-up
- What would you have done if they had not changed their behaviour?
- When did you decide to involve your manager, and what did you tell them?
- What did that experience change in how you work with people?
How do you prioritize tasks when working on multiple projects?
How do you prioritize tasks when working on multiple projects?
Approach
- State the method before the story: list every commitment, note who is blocked on each, rank by user impact and deadline, estimate effort, and flag dependencies. Cheap, high-impact items go first, and anything that blocks a teammate usually jumps the queue.
- Use one real example with a collision, such as a production bug during sprint work or two features due the same week. Name the items, the order you chose, and the reason for the order.
- Show that you communicated the trade-off: you told the product manager or lead what would slip and agreed the new order with them, instead of quietly working longer hours.
- Describe how you keep it honest day to day: one visible list, a daily re-rank, and explicit no or not-this-sprint answers backed by the reason.
- The mistake that sinks it is claiming you simply do everything or work harder. Answers with no trade-off and no stakeholder conversation sound like you have not had to choose.
Follow-up
- What did you drop or delay in that example, and who did you tell?
- How do you handle an urgent request that arrives mid-sprint?
- How do you decide when two items look equally important?
Describe a situation where you had to learn a new technology quickly. What was your approach?
Describe a situation where you had to learn a new technology quickly. What was your approach?
Approach
- Pick a technology you had to use for real work under a deadline, ideally close to the listed stack (React, Node.js, a database such as MongoDB, or a cloud service), and say what was at stake and by when.
- Describe a method, not just effort: read the official documentation for the core concepts, build a small spike that exercises the risky part, read how existing code in the team uses it, and ask a colleague to review your first attempt.
- Show how you checked your understanding: tests, a code review, or explaining it to a teammate. Name one mistake you made on the way and how you caught it.
- End with what shipped and what you still did not know. Honest scope ("I knew enough to build X, and I had a reviewer for Y") is stronger than claiming mastery in a short time.
- The mistake that sinks it is listing courses and tutorials with nothing built, or naming a technology you cannot discuss in detail when asked a follow-up.
Follow-up
- What did you leave out to hit the deadline, and what was the risk?
- How did you know your understanding was correct and not just working?
- How do you decide whether to learn a tool deeply or use it shallowly?
How do you handle feedback on your work?
How do you handle feedback on your work?
Approach
- Use a specific piece of critical feedback, most naturally from a code review or a design discussion, not a vague or flattering one. Say what the feedback was and who gave it.
- Show your first response: you asked clarifying questions or for an example, separated the point from the delivery, and took time to check whether it was right before reacting.
- Show what you changed and how you confirmed it landed, for example you updated the pull request, adopted a review checklist, and went back later to ask whether the change helped.
- If you disagreed, show how you handled it with evidence (benchmarks, a test case, or the spec) and stayed willing to be wrong. Add a line on how you give feedback to others, since the same skill applies on both sides.
- The mistakes that sink it are defensiveness, a fake weakness ("I care too much"), or a story where nothing changed afterwards.
Follow-up
- Tell me about feedback you disagreed with, and what you did.
- How do you ask for feedback when no one is offering it?
- How do you give feedback on a teammate's pull request?
- 01
Tell me about a time you had to work with a difficult team member.
- 02
How do you prioritize tasks when working on multiple projects?
- 03
Describe a situation where you had to learn a new technology quickly. What was your approach?
- 04
How do you handle feedback on your work?
- 05
Describe a time when you encountered a technical challenge. How did you resolve it?
- 06
Tell me about a time when you had to work with a cross-functional team.
How many rounds does the Blue Nile Software Engineer loop have?
Candidates report four rounds over roughly three to five weeks: an HR Screen, Technical Interviews, a Coding Skills Demonstration and Problem-Solving Discussions. Since the reports give names and short descriptions only, ask your recruiter for the exact format and the languages allowed in each stage.
Blue Nile Software Engineer candidate reports ↗How long should I prepare?
Candidate advice is to spend about two to four weeks, depending on how fresh your fundamentals are. The seven-day plan in this guide covers each reported topic once and ends with a mock run, so use it as the final week and add earlier weeks for areas such as SQL tuning or system design if they are weak.
Blue Nile Software Engineer candidate reports ↗What topics do candidates report being tested on?
The topic areas candidates list are data structures and algorithms, SQL, DBMS, operating systems and computer networks. The reported questions turn those into string and array coding problems, binary search, SQL versus NoSQL, slow-query tuning, REST, object-oriented design, exception handling, asynchronous code and e-commerce system design.
Blue Nile Software Engineer candidate reports ↗Which programming language should I use?
Candidates describe the role as listing JavaScript, Python or Java, with React, Angular or Node.js on the web side. Use the language you can write fastest and test most reliably, and confirm with the recruiter whether the Coding Skills Demonstration restricts the choice.
PracHub Software Engineer practice ↗Is there a take-home or a live coding exercise?
Candidates report a Coding Skills Demonstration based on practical exercises, but do not report whether it is live or a take-home. Ask at the HR Screen. In either case, practise writing short, tested functions and explaining your choices, since the reported coding questions are small and well known.
PracHub Software Engineer practice ↗What should I know about the business?
Blue Nile is an online jeweler, so a useful angle is the shopping flow: browsing a large catalog, filtering, product pages, cart and checkout. Think about what that means for performance, search and filtering, inventory accuracy and payment errors, because your design and debugging answers can use those examples.
PracHub Software Engineer practice ↗Sources & methodology 3 sources ↗
No official company page is cited. Rounds and questions come from candidate reports and PracHub editorial material; each source shows the date it was read.
- 01Blue Nile Software Engineer candidate reports ↗
Company-reported rounds, questions and FAQ.
Candidate reports · Accessed 2026-09-22 - 02PracHub Software Engineer practice ↗
PracHub practice material, not company-reported.
PracHub page · Accessed 2026-09-22 - 03PracHub preparation framework ↗
PracHub preparation guidance.
PracHub page · Accessed 2026-09-22
Explore related engineering environments and compare the preparation focus.
Cognition Software Engineer Interview Guide
What Cognition asks Software Engineer candidates, from reported rounds and questions.
Vercel Software Engineer Interview Guide
Debugging practice for Vercel software engineer prep built on a reproduction you trust, narrowing to the smallest failing input, and changing one variable per run so the result stays attributable.
Together Ai Software Engineer Interview Guide
Failure-handling practice for Together Ai software engineer candidates: requests whose outcome a timeout leaves unknown, where a retry is safe, and deduplicating at the receiver instead of assuming exactly-once delivery.
Spotify Software Engineer Interview Guide
Timed practice for Spotify software engineer candidates who lose time to the clock: short problems taken end to end, then reviewed against a written rubric rather than a passing test run.