1-800-FLOWERS.COM, Inc. Software Engineer Interview Guide

The 60-second brief

1-800-FLOWERS.COM, Inc. runs an e-commerce business whose demand peaks around holiday seasons. Candidates say the Software Engineer role covers the customer-facing platforms and also the logistics and supply chain systems behind them, including Oracle Cloud WMS (LogFire). Reported day-to-day work runs from requirements through deployment and maintenance, and includes hands-on coding, code reviews and architecture design sessions with product managers and other engineers. Example projects candidates mention are better inventory tracking and more reliable logistics platforms. The requirements candidates describe are a modern programming language, experience with an enterprise WMS or a similar logistics platform, database management and cloud architecture. Oracle Cloud and large-scale e-commerce logistics count as a plus.

This guide is for software engineers preparing for the 1-800-FLOWERS.COM, Inc. Software Engineer loop. It fits two backgrounds: backend or platform engineers with no warehouse experience, and engineers from WMS or supply chain work who have done less distributed-systems design. It covers both reported rounds and gives an approach and follow-ups for each of the twelve reported questions. It also explains the warehouse and integration concepts behind the domain questions, peak-traffic and fault-tolerance design, the Oracle Cloud Infrastructure vocabulary to map your cloud experience onto, and the behavioral stories to prepare. A seven-day plan adds practice problems on SQL and coding fundamentals.

Candidates report two rounds over roughly 2-4 weeks. First comes a Technical Screening, then an Onsite or Virtual Interview made of in-depth sessions that can add up to several hours.

Focus areas

• WMS (Warehouse Management Systems)
• Oracle Cloud Infrastructure (OCI)
• Technical Leadership

Overview

None of the reported questions for this loop is an algorithm drill. They fall into three groups. Technical and domain expertise covers Oracle Cloud WMS experience, data reconciliation at volume, troubleshooting production performance and code quality on logistics software. System design and architecture covers a service that survives a traffic surge, fault tolerance, a diagram of a warehouse management integration, and technical debt versus delivery speed. Behavioral problem-solving is the third. Candidates also report two scenarios: speeding up a slow database query in a supply chain application, and moving a legacy module to a cloud-based architecture.

If you come from general backend work, close the domain gap first. Candidates describe the role as touching logistics and supply chain systems, including Oracle Cloud WMS (LogFire), with work on inventory tracking and the reliability of logistics platforms. Learn the warehouse flow: receiving, putaway, allocation, waves, picking, packing, shipping and cycle counts. Learn which system owns which data, and how items, orders, receipts and shipment confirmations move between an order system, an ERP and a WMS. That one picture answers the WMS experience question, sets up the reconciliation question, and is the diagram the integration question asks for.

The design questions share one setting: an e-commerce business whose load jumps around seasonal peaks. Your answers need to handle four problems. Orders arrive in bursts. Popular items cause contention on the same inventory rows. A downstream system with fixed throughput cannot keep up with incoming orders. Retries must not create duplicate orders or subtract stock twice. Candidates list data consistency models, cloud-native deployment and API security as advanced concepts, and those are the terms to use in these answers. For deployment, be concrete: container images on an orchestrator, health and readiness probes, and blue-green or canary releases finished well before a seasonal peak.

Candidates report drawing system designs or logic flows on a whiteboard. Their tips also stress explaining your own contribution to past projects and the trade-offs behind it. Practise every design answer as a drawing you talk through. Prepare two projects you can explain decision by decision, in the first person singular.

The 1-800-FLOWERS.COM, Inc. interview process

Candidates report two stages and do not say which questions come up in which. Prepare the domain questions and project summaries before the screening, and the design drawings and behavioral stories before the second round, while keeping every reported question in rotation.

Technical Screening

Candidates describe the Technical Screening as an initial assessment of baseline skills, and some call it a phone screen. Nobody reports which topics or questions belong to it. The role lists a modern programming language, database management, cloud architecture and warehouse or logistics systems, so refresh those areas before the screening. Be ready to explain your recent projects in your own words, with your own contribution and one trade-off for each. Prepare the domain questions in short form first, then keep a longer version of each ready.

What to demonstrate

• Baseline technical skills, as candidates describe this stage
• Preparation advice: be ready to explain your past work, your own part in it and the trade-offs you made

How to prepare

• Write and rehearse a short spoken summary of two projects: the system, your part, one trade-off and its measured result.
• Refresh database fundamentals: composite indexes, reading an EXPLAIN plan, isolation levels, and how you find the slowest queries in production.
• Learn the warehouse vocabulary end to end (receiving, putaway, allocation, waves, picking, packing, shipping, cycle counts, LPNs) and read up on Oracle Cloud WMS (LogFire), the system candidates name for this role.
• Write a one-paragraph answer on your WMS experience. Be honest about gaps and map what you know from the system you did use.

Onsite or Virtual Interview

Candidates describe the Onsite or Virtual Interview as a set of in-depth sessions on your depth of experience, which together can run several hours. Because the stage is reported to test depth, prepare two or three projects you can take apart layer by layer: architecture, data model, a failure you handled, a number you moved. Prepare to treat each session as a technical discussion, and be ready to defend each design choice against a counter-proposal. Candidates report drawing system designs or logic flows on a whiteboard in this loop, so practise drawing your design answers while explaining each box and arrow. If the session is virtual, practise the same diagrams in an online whiteboard tool so drawing does not slow you down.

What to demonstrate

• Depth of experience, which candidates report these sessions are built to test
• Explaining and defending your technical choices in detail
• Sustained, detailed technical conversation across several sessions

How to prepare

• Draw a warehouse management integration and a service built for a traffic surge. For each, walk one order through from end to end, then walk one failure path.
• For two projects, write out the layers you can defend: architecture, data model, a failure you handled and a metric you improved.
• Rehearse the slow-database-query and legacy-to-cloud scenarios candidates report, each as a story with a measured outcome.
• Oracle Cloud Infrastructure is a reported topic, so translate the cloud parts of your design answers into OCI terms (compartments and IAM policies, VCN, Compute or OKE, Object Storage, Autonomous Database, API Gateway, Streaming or Queue) and be ready to explain a rolling or blue-green deploy of a containerised service.

Where candidates lose points

Describing Oracle Cloud WMS experience as a list of modules, with no data flow and no problem you owned

Walk one entity through the systems, for example a customer order going from the order system into the WMS and coming back as a shipment confirmation, and name the integration problem you fixed along the way. If your experience is with a different WMS or ERP, say so and map the same flow onto it.

A reconciliation answer that compares two totals and stops there

Name the system of record for each entity and a shared cut-off. Explain idempotent ingestion keyed on source transaction ids. Explain how you sort mismatches by type: timing, unit of measure, duplicates, real loss. Without these, every in-flight transaction shows up as a discrepancy.

A traffic-surge design that amounts to 'add autoscaling'

Autoscaling lags a spike, and it does not help with a single hot inventory row or a downstream system with fixed throughput. Add scaling ahead of known peaks, a queue between accepting orders and fulfilling them, conditional updates or reservations for hot SKUs, rate limiting, and features you can switch off.

Drawing boxes in silence, or talking through a design without drawing it

Candidates report drawing system designs and logic flows on a whiteboard. Practise talking while you draw: label every arrow with the data it carries, walk one request through, then walk one failure through. Rehearse with the tool you will use, either a physical whiteboard or an online canvas.

Telling project stories about what 'the team' did, so your own part is unclear

For each project, write down the decisions you personally made and one trade-off you weighed, and tell the story in the first person singular. When asked why, name the option you rejected and the reason.

Questions & practice

Find overlapping job attempts and peak concurrency from lease records

Medium · sweep line · intervals · leases

A day of job_run history yields about 50,000,000 attempt records: (job_run_id, job_type, attempt, started_at, finished_at which is NULL when the worker died, lease_expires_at). Leases expire on a clock, so a job that outran its lease ran twice. Produce (a) every job_run_id whose attempts overlapped in wall-clock time and (b) the peak number of simultaneously running attempts per job_type with the minute it occurred. Target O(n log n). State how you treat a NULL finished_at and what clock skew does to your answer.

Approach

1. Define the interval before sorting anything: an attempt occupies [started_at, COALESCE(finished_at, lease_expires_at)). finished_at is observed and lease_expires_at is only a promise, so every attempt without a finish contributes an estimate and the whole result is a lower bound on overlap rather than an exact count.
2. For peak concurrency, sweep: emit 2n endpoints, sort by (timestamp, kind) with ends ordered before starts at equal timestamps, then walk the sequence maintaining a counter per job_type and record each type's maximum with its timestamp. O(n log n) dominated by the sort, O(n) space, or O(1) extra if the sort is external and the walk streams.
3. For overlap detection, do not compare attempts pairwise. A single global sort by (job_run_id, started_at) gives both the grouping and the order; within a group, keep the maximum end seen so far and report an overlap exactly when the next start is less than that running maximum, which is one linear pass after the sort.
4. Half-open intervals matter and are easy to get wrong: with closed intervals an attempt ending at the same millisecond another begins reads as concurrency two, and across 50,000,000 records that artefact swamps the real signal.

Follow-up

• A handler is not idempotent and you have found 400 overlapping jobs. Which of them actually caused damage, and what would you query to find out?
• Peak concurrency for one job_type is 4 against a configured cap of 4. Is the cap working, or is the data hiding attempts that never started?

Identify the heaviest tenants in a five-minute window under memory pressure

Medium · top-k · heavy hitters · streaming

The edge service handles about 3,000 requests per second across roughly 50,000 tenants, peaking near 9,000. Expose the 50 heaviest tenants by request count over the trailing five minutes so limits can be tightened before one tenant's backfill starves the fleet. You may not retain five minutes of raw records. Give the exact solution and its memory, then the bounded-memory approximation with its error stated as a formula, and say which you would ship and at what tenant cardinality that choice changes.

Approach

1. Do the exact version first, because it is affordable at this cardinality: a ring of 300 one-second counters per tenant, advanced lazily, is 1,200 bytes of counters per tenant and roughly 60 to 90 MB for 50,000 tenants with overhead. Carry a running total and subtract the bucket you overwrite so a window read is O(1) rather than 300 adds.
2. Extract the top 50 with a size-k min-heap over the tenant sums: O(d log k) for d tenants, against O(d log d) to sort them all. Maintaining the heap continuously instead of on query requires a tenant-to-heap-index map, because incrementing a count already inside the heap means sifting from a known position, and without that map you rebuild the heap on every request.
3. State the approximation precisely rather than gesturing at sketches. Misra-Gries with m counters retains every item whose true count exceeds N/(m+1), and each retained count underestimates the truth by at most N/(m+1). With m = 1,000 and N = 900,000 requests in the window the error is roughly 900 requests, which is fine for spotting a tenant sending 50,000 and useless for ranking two tenants 200 apart.
4. Say what breaks when the window slides: Misra-Gries and Space-Saving are insert-only and cannot be decremented as records age out. The workable construction is one summary per sub-window, say ten seconds, with 30 summaries merged at query time, and the merged error is the sum of the per-summary errors, so the bound degrades linearly in the number of sub-windows.

Follow-up

• The heaviest tenant is heavy because of one export job rather than user traffic. Should the limiter treat those as the same tenant?
• Two tenants sit tied at the boundary of the top 50. Does your answer flap, and does the flapping matter?

Archive a resource graph without breaking live references or recursing

Medium · graph traversal · topological order · tenant isolation

Resources reference other resources within a tenant; for the largest tenant the reference table holds up to 2,000,000 nodes and 8,000,000 edges. Archiving a resource must archive everything reachable from it that nothing outside the set still references, refuse when a live external referrer exists, and terminate when references form cycles, which they legitimately do. Produce the archive order and the refusal list, targeting O(V+E). Say what stops the traversal crossing a tenant boundary, and why recursion is the wrong control structure at this size.

Approach

1. Load the subgraph with the tenant predicate on both endpoints of the edge, not only on the side you started from. Scoping the left table alone is the classic cross-tenant leak: one mis-entered edge then pulls another tenant's resources into the traversal and, worse, into the archive.
2. Traverse iteratively with an explicit stack. A 2,000,000-node graph can hold a chain deep enough to exhaust a native stack in the low tens of thousands of frames, and that failure is a process crash rather than an error you can return.
3. Treat cycles as data rather than corruption: compute strongly connected components with Tarjan in O(V+E) using its own explicit stack, then condense. The condensation is a DAG, so a topological order over it gives the archive order, and every member of a component archives in one transaction because no order within a cycle is valid.
4. Decide refusals with reverse edges. A candidate is archivable only if every in-edge originates inside the candidate set, so build the transpose or count in-degrees restricted to the visited set, and emit each blocked resource with the id of the external referrer, which is the only part of the answer an operator can act on.

Follow-up

• The graph is read in one query and the archive writes a minute later. What can change in between, and how do you make the write safe?
• The candidate set is 400,000 resources. Is that one transaction, and if not, what does a half-finished archive look like to a reader?

Find version gaps and relay lag with window functions

Medium · window functions · event tables · frame semantics

outbox_event holds event_id, aggregate_type, aggregate_id, aggregate_version, event_type, payload, status ('pending','published','dead'), attempts, created_at, published_at. A projection is missing rows and you must decide whether the relay skipped events or the consumer dropped them. Write three queries over the last seven days: one listing every aggregate_id whose published aggregate_version sequence has a hole, one giving per-day counts with a running total, and one returning the newest published event per aggregate. For each, say where the window function is evaluated relative to WHERE and LIMIT. PostgreSQL 16.

Approach

1. Gaps: compute lead(aggregate_version) OVER (PARTITION BY aggregate_id ORDER BY aggregate_version) in a subquery, then filter next_version <> aggregate_version + 1 in the outer query. Window functions are evaluated after WHERE, GROUP BY and HAVING and before the outer ORDER BY and LIMIT, so the predicate cannot sit in the same WHERE clause and PostgreSQL 16 has no QUALIFY.
2. Say what the seven-day filter does to the answer: it truncates every partition, so the first row per aggregate has no predecessor inside the window and a hole spanning the boundary is invisible. Widen the window, or join to resource.version as the authority for the true maximum.
3. Running total: SELECT date_trunc('day', created_at) AS d, count() AS n, sum(count()) OVER (ORDER BY date_trunc('day', created_at) ROWS UNBOUNDED PRECEDING). An aggregate inside a window call is legal because grouping runs before windowing. The grouping key is unique per row here so ROWS and RANGE agree, but write the frame anyway — over ungrouped rows with tied timestamps the default RANGE frame pulls in every peer row and the total jumps.
4. Newest per aggregate: DISTINCT ON (aggregate_id) ... ORDER BY aggregate_id, aggregate_version DESC is the cheap PostgreSQL-only form when an index matches that order; row_number() OVER (PARTITION BY aggregate_id ORDER BY aggregate_version DESC) = 1 is the portable form and needs a subquery for the same evaluation-order reason as the gap query.

Follow-up

• Relay failover redelivers events. Does a duplicate break the gap query, and how would you detect one from this table alone?
• Turn the gap check into a continuous monitor rather than a query someone runs after an incident. What does it watch?

Denormalise tenant onto revisions and backfill it live

Hard · denormalisation · online migration · backfill

resource_revision (revision_id, resource_id, version, actor_user_id, change_kind, patch, request_id, created_at) has 400M rows and no tenant column; tenant_id lives only on resource. Two reads need it: a tenant-scoped audit feed ordered by created_at DESC, and an offboarding purge. Both join back to resource today. Justify adding tenant_id to resource_revision against those two reads, name the anomaly the copy introduces and the constraint that prevents it, then give the ordered migration for a live table taking 1.2k writes/second — the lock each step takes, how the backfill is batched, and where each step stops being reversible. PostgreSQL 16.

Approach

1. Justify from the access path rather than from taste. Without the column, the audit feed either scans resource_revision by created_at and discards other tenants' rows, or resolves the tenant's resource_ids first and probes with them — both proportional to the tenant's whole history rather than to one page. With (tenant_id, created_at DESC, revision_id DESC) it is a seek that stops at 50 rows, and the purge becomes a ranged delete instead of a join.
2. Name the cost exactly: a second copy of a fact can disagree with the first. Make the disagreement unwritable rather than documented — add UNIQUE (resource_id, tenant_id) on resource so it can serve as a foreign-key target, then FOREIGN KEY (resource_id, tenant_id) REFERENCES resource (resource_id, tenant_id) on the revision table. A revision can then only ever carry its parent's tenant.
3. Step one, expand: ALTER TABLE resource_revision ADD COLUMN tenant_id BIGINT NULL, with no default, so it is a catalogue change and no rewrite. It still needs ACCESS EXCLUSIVE for an instant, and that instant queues behind the longest open transaction on the table while every later query queues behind it — set lock_timeout to 2s and retry rather than wait.
4. Step two, dual-write: deploy the writer that populates tenant_id on every new revision while reads still use the join. Reversible by redeploying the previous build, because nothing reads the column yet.

Follow-up

• The backfill is half finished and a rollback is required. What state is the table in, and what does the previous build do with a half-populated column?
• How do you verify the backfill actually finished, given rows are still being inserted while it runs?

What strategies do you use to ensure code quality when working on mission-critical logistics software?

Medium · Technical and Domain Expertise

Approach

1. Start with what a defect costs in logistics. A wrong allocation ships the wrong item or oversells stock, and a duplicated message subtracts inventory twice. Then tie each quality practice to the failure it prevents.
2. Test at the right layers. Unit tests cover allocation and inventory arithmetic. Property-based tests check invariants: on-hand stock never goes negative, and a move between locations keeps the total the same. Contract tests run against recorded WMS and ERP payloads. Replay tests send the same message twice to prove processing is idempotent.
3. Add gates in the pipeline. Code review uses a checklist covering error handling, retries, idempotency and logging. Add static analysis and type checks, and validate the schema at every integration boundary. A bug fix merges only with a test that failed before the fix.
4. Release safely. Use feature flags and a canary or single-facility rollout, and keep a tested rollback path. Watch business signals (orders released, picks confirmed, open mismatches) as well as technical ones. Tighten the change policy before a known seasonal peak.
5. Give one example where a practice caught a real defect, so the answer rests on evidence rather than a list.

Follow-up

• How do you test integration with a third-party WMS you cannot run locally?
• A bug double-allocated stock last week. What test would have caught it?
• How do you keep code review from slowing delivery?

Walk me through how you would architect a service to handle a sudden surge in traffic.

Medium · System Design and Architecture

Approach

1. Clarify the surge first. Is it read-heavy browsing or write-heavy checkout? How many times normal load? Is it predictable, like a holiday, or sudden? Which operations must never fail (order placement, payment) and which can degrade (recommendations, reviews)?
2. Read path: a CDN and edge caching for static and catalog content, an application cache with explicit expiry in front of the database, read replicas, and stateless services behind a load balancer so you can add instances freely.
3. Write path: accept the order and save it with an idempotency key. Put the downstream work (inventory reservation, release to the WMS, emails) on a queue so bursts are absorbed and consumers run at a sustainable rate. Protect hot rows, such as inventory for a popular SKU, with conditional updates (decrement only if stock remains), reservations that expire, or split counters in which each shard owns a fixed allotment of the stock, so a decrement checks only its own shard.
4. Capacity controls: scale up ahead of known peaks, because autoscaling only reacts after the load arrives. Rate-limit and apply backpressure at the edge, cap connection pools per service, put circuit breakers on slow dependencies, and add switches that turn off non-essential features under load.
5. Prove it. Load test at the target multiple, use queue depth and consumer lag as the scaling signals, and name the bottleneck you expect first. It is usually the database, or a downstream system in your design that has a fixed throughput.

Follow-up

• Inventory for one SKU is oversold during the spike. How do you prevent it?
• Suppose the downstream warehouse system can accept orders only at a fixed rate. What does your queue do?
• What do you turn off first when the database saturates?

How do you design for fault tolerance in a distributed system?

Medium · System Design and Architecture

Approach

1. List the failure modes before the techniques: a process or node crash, a zone outage, a network partition, a dependency that is slow rather than down, and poison messages or bad data.
2. For every remote call: set a timeout, and retry with exponential backoff and jitter only for idempotent operations. Add a circuit breaker so a slow dependency fails fast, and bulkheads (separate pools) so one bad dependency cannot use up every thread.
3. For every data change: use idempotency keys so retries are safe. Use the transactional outbox so a database write and the event announcing it cannot get out of step. Use sagas with compensating actions instead of distributed transactions across services. Send messages that keep failing to a dead-letter queue you can replay.
4. State your consistency choice. Say which data must be strongly consistent (payment, inventory reservation), which can be eventually consistent (order status views, search), and what a user sees during a partition.
5. Cover redundancy and safe deploys: replicas across availability zones; services shipped as container images on an orchestrator, with health and readiness probes that keep bad instances out of rotation; blue-green or canary releases finished well ahead of a seasonal peak; and failure-injection tests that prove the fallbacks work.

Follow-up

• Retries from many clients are now overloading the recovering service. What went wrong, and how do you fix it?
• How do you make sure an order is never reserved twice when a message is delivered twice?
• When would you accept a stale read, and how stale?

Draw a high-level architecture diagram for a warehouse management integration.

Medium · System Design and Architecture

Approach

1. Draw the boundaries first: the order source (e-commerce platform or order management), the ERP for item master and purchase orders, the WMS (Oracle Cloud WMS if you know it), the carriers, and an integration layer between them. Label every arrow with the entity it carries and its direction.
2. Flows into the WMS: item master, purchase orders or ASNs, and customer orders released for fulfilment. Flows out of it: receipt confirmations, shipment confirmations with tracking, and inventory adjustments and snapshots. Point out the ordering dependency: an order line fails if its item has not been loaded yet.
3. Inside the integration layer: a durable queue per flow, transformers from a common data model to the WMS format (API payload or file), idempotent consumers keyed on source ids, a dead-letter queue with replay, and an audit store that records every message and acknowledgement for reconciliation.
4. Pick sync or async for each flow. Order release and confirmations go through queues. Show customers stock levels from a cached inventory view that WMS events keep up to date, not a live call to the WMS on every page view. Cover API security: authenticated and encrypted calls, secrets kept in a vault, and least-privilege credentials for each integration.
5. Walk one order from end to end while pointing at the diagram. Then walk one failure path: when the WMS is unavailable, orders build up in the queue, release resumes in order, and nothing is lost.

Follow-up

• A customer cancels after the order was released to the warehouse. What flows where?
• How does the design change when you add a second warehouse or a third-party logistics provider?
• Batch file interface or real-time API: which would you choose for inventory sync, and why?

How do you balance technical debt with the need for rapid feature delivery?

Medium · System Design and Architecture

Approach

1. Treat debt like a loan with interest. Measure the interest: time added to every change in that area, incidents it causes, on-call pages. Pay down the most expensive debt first, not the ugliest code.
2. Make it visible. Keep a short register of debt items with their cost and risk, and review it alongside the feature roadmap with the product manager, so trade-offs are agreed in the open rather than hidden.
3. Use habits that keep delivery moving: fix debt in code a feature already touches, reserve a steady share of capacity for it, and take shortcuts on purpose only with a written trigger for paying them back, such as before the next seasonal peak.
4. For large legacy pieces, use the strangler-fig pattern: put a facade in front, move one capability at a time behind it, and retire the old path when its traffic reaches zero. This matches the reported scenario of moving a legacy module to a cloud-based architecture.
5. Back the answer with one real story: the debt, what it cost, the case you made, what you shipped, and what changed in incident count or lead time.

Follow-up

• Tell me about debt you took on deliberately. Was it worth it?
• The product manager says there is no room for this work this quarter. What do you do?
• How do you decide a rewrite is justified instead of incremental cleanup?

Explain your approach to troubleshooting a performance bottleneck in a production environment.

Medium · Technical and Domain Expertise

Approach

1. Measure the symptom before forming a theory: which metric (p50 or p99 latency, throughput, error rate), which endpoints or jobs, which hosts, and since when. Then list what changed in that window: deploys, configuration, traffic mix, data volume, a dependency.
2. If customers are affected, mitigate first: roll back, scale out, or turn off the feature behind a flag. Then diagnose once the pressure is off. Say this out loud so the answer covers running production, not only the analysis.
3. Narrow it down with traces and resource metrics. A distributed trace shows which span got slower. For each resource, check utilisation, saturation and errors: CPU, memory and GC pauses, thread or connection pool exhaustion, disk and network. Requests waiting on a pool while CPU is low usually mean a slow dependency or lock contention, not a compute shortage.
4. For a slow database query (candidates report this scenario for a supply chain application), pull the statement from the slow-query log or statement statistics and run EXPLAIN ANALYZE. Look for full scans of large tables, row estimates that are far off (stale statistics), N+1 calls from the ORM, a missing composite index that matches the WHERE and ORDER BY columns, or lock waits. Fix it, then measure the same metric again.
5. Finish the job: confirm the fix moved the original metric, add an alert or dashboard that would have caught the problem sooner, and write down the cause so the next seasonal peak does not repeat it.

Follow-up

• p99 latency doubled but p50 is flat. What does that suggest and where do you look?
• CPU is low yet requests are slow. Name three causes.
• How would you reproduce the problem without load-testing production?

Suggested practice checklist

Each day covers one cluster of reported questions for this loop. Days 1-5 work through the warehouse domain, reconciliation, performance and design, and Days 2-5 add practice problems for SQL and coding fundamentals. Day 6 covers technical debt, legacy migration and Oracle Cloud Infrastructure; Day 7 is behavioral stories and a full rehearsal.

Day 1 — Warehouse domain and your WMS story

• Draw the warehouse flow from receiving to shipping and mark which system owns each step's data: ERP, WMS, order system or carrier.
• Write your answer on Oracle Cloud WMS experience and say it aloud: the system map, one integration problem, the measured result, and any honest gaps.
• Write short spoken summaries of two projects for the screening: the system, your part, one trade-off.

Deliverable: A labelled warehouse flow diagram, a rehearsed answer on WMS experience, and two project summaries.

Day 2 — Data reconciliation and SQL

• Write the reconciliation query: total WMS and ERP inventory by SKU and facility at one cut-off, FULL OUTER JOIN the two, and keep the mismatched rows.
• Outline the reconciliation pipeline (idempotent ingestion, mismatch types, an exception queue), then answer the data reconciliation question aloud.
• Solve the window-function question on version gaps and relay lag to practise spotting missing or late records in a sequence.

Deliverable: A working reconciliation query, a one-page pipeline outline, a spoken answer and a solved window-function exercise.

Day 3 — Production performance and slow queries

• Seed a local database table with a few million rows, run a slow filtered and sorted query, read EXPLAIN ANALYZE, add the matching composite index, and record the plans before and after.
• Write your sequence for troubleshooting a production bottleneck as a one-page runbook, from symptom to verification.
• Solve the heaviest-tenants question to practise windowed aggregation under memory limits.
• Answer the performance troubleshooting question aloud, using a real incident of your own.

Deliverable: Query plans from before and after the index, a troubleshooting runbook, a solved coding exercise and a spoken incident answer.

Day 4 — Peak traffic and fault tolerance

• Whiteboard the traffic-surge service: the read path, the queued write path, protection for hot-SKU inventory, and what you switch off under load.
• List the failure modes for that design and pair each with a mechanism: timeouts, backoff with jitter, circuit breakers, an outbox, a dead-letter queue, readiness probes and a blue-green or canary rollout.
• Solve the overlapping-job-attempts question to practise reasoning about intervals and peak concurrency.

Deliverable: An annotated surge diagram, a table pairing failure modes with mechanisms, and a solved concurrency exercise.

Day 5 — WMS integration diagram and code quality

• Draw the warehouse management integration from memory on a whiteboard or online canvas. Walk one order through from end to end and talk through the WMS-down failure path. Record it and watch it back.
• List your code-quality practices for logistics software, each paired with the defect it prevents and one real example.
• Solve the denormalise-and-backfill question to practise changing a live schema without downtime.

Deliverable: A recorded walkthrough of the integration, a table pairing practices with defects, and a solved backfill exercise.

Day 6 — Technical debt, legacy migration, OCI and learning

• Write your technical debt story (its cost, the case you made, the outcome) and a strangler-fig plan for moving one legacy module to the cloud.
• Map your cloud stack onto Oracle Cloud Infrastructure: compartments and IAM policies, a VCN with subnets, Compute versus OKE, Object Storage, Autonomous Database, API Gateway, and Streaming or Queue. Then outline a cloud-native deploy there: a container image in the registry, a rolling or blue-green rollout on OKE, and readiness probes gating traffic.
• Write your story about ambiguous requirements and your story about learning a new stack, each ending with what shipped.
• Answer the debt, ambiguity and learning questions aloud and cut every sentence that does not move the story forward.

Deliverable: Three rehearsed stories, a one-page plan for migrating a legacy module, and a one-page OCI map with a deployment outline.

Day 7 — Communication stories and full rehearsal

• Write and rehearse the non-technical stakeholder story and the technical disagreement story in STAR form.
• Run a mock: a friend picks two technical, one design and two behavioral questions from this guide, and you answer and draw without notes.
• Write questions for your interviewers about the team's current technical challenges.

Deliverable: Two rehearsed stories, notes from one full mock with weak spots marked, and a list of questions for your interviewers.

Behavioural preparation

The reported behavioral questions cover four areas: explaining technical issues to non-technical people, resolving a technical disagreement, working with unclear or shifting requirements, and learning a new stack quickly. Build each story around a decision you made yourself, the option you rejected and a result you can measure. Examples from logistics work fit this role closely: an inventory mismatch, a peak-season incident, a warehouse integration.

1. Describe a scenario where you had to transition a legacy module to a modern cloud-based architecture.

Describe your experience integrating or managing Oracle Cloud WMS solutions.

Medium · Technical and Domain Expertise

Approach

1. Start with the system map, not your job title. Say where Oracle Cloud WMS sat between your order source, the ERP and the carriers. List the entities that crossed each boundary: item master, purchase orders or ASNs, customer orders, receipts, shipment confirmations and inventory snapshots. Say whether each flow used an API or a file-based interface.
2. Then describe one integration problem you owned from start to finish. Two examples: order lines rejected because the item had not reached the WMS yet, or inventory counts drifting apart between the WMS and the ERP. Explain how you detected it, how you fixed it (dependency ordering, a hold-and-retry queue, a scheduled sync) and what changed afterwards.
3. Show you know the warehouse flow the data drives: receiving, putaway, allocation, wave planning, picking, packing, shipping, cycle counts and LPN tracking. Saying exactly where a bad message breaks that flow is the concrete core of the answer.
4. If you have not used Oracle Cloud WMS, say so in one sentence. Then map from the WMS or ERP you did use (Manhattan, Blue Yonder, SAP EWM or an in-house system): the same entities, the same failure modes. Name what you would check first in the Oracle integration documentation.
5. Use I for your own decisions. Keep the background short and spend most of the answer on the problem and the trade-off.

Follow-up

• What happened to orders while the WMS interface was unavailable, and how did they catch up?
• How did you keep the item master consistent between the ERP and the WMS?
• What would you change about that integration if you rebuilt it on current cloud services?

How do you handle data reconciliation in a high-volume supply chain environment?

Medium · Technical and Domain Expertise

Approach

1. First name the system of record for each entity. The WMS owns physical on-hand stock by location. The ERP or order system owns financial inventory and orders. Reconciling means checking each copy against its owner, not averaging the two.
2. Make ingestion idempotent so you are not chasing duplicates. Give every transaction a unique key (message id or source transaction id), write it as an upsert or insert-if-absent into a ledger, and make processing tolerate events that arrive out of order.
3. Explain the comparison. Snapshot both sides at the same cut-off and total quantities by SKU and facility. FULL OUTER JOIN on (sku, facility) and keep rows where COALESCE(wms_qty,0) <> COALESCE(erp_qty,0). At high volume, compare totals or hashes per partition first, and examine individual rows only in the partitions that differ.
4. Sort each mismatch into a type: a timing difference (posted on one side after the cut-off), a unit-of-measure mismatch (cases versus single units), a duplicate or missing message, or real physical loss. Clear timing differences automatically once a tolerance window passes. Send the rest to an exception queue with an owner. Track how many mismatches are open and how old they are.
5. Edge cases to mention: events that arrive after the snapshot, partial shipments, returns, cancellations after an order is released to the warehouse, and a reconciliation job that fails partway (make it restartable per partition).

Follow-up

• How do you tell a timing difference from real shrinkage without a manual count?
• A shipment confirmation arrives twice and inventory is decremented twice. Where do you fix it?
• How would you run this continuously instead of as a nightly batch?

Describe a time you had to explain a complex technical issue to a non-technical stakeholder.

Medium · Behavioral and Problem-Solving

Approach

1. Pick a case where the stakeholder had a real decision to make: delay a launch, fund a fix, or accept a risk before a peak. A story that ends with 'I explained it and they understood' has no stakes.
2. Structure it like this. Give the situation in two sentences and say what the stakeholder needed to decide. Say how you translated the problem: an analogy, a diagram, or the impact in their own units, such as orders delayed or stock misreported. Lay out the options you offered and their trade-offs. Finish with the decision and the outcome.
3. Show that you checked they understood: they restated it in their own words, or you sent a short written summary they could pass on.
4. Avoid the two answers that sink this question: one that makes the stakeholder look slow, and one where you simplified until the explanation was wrong. A logistics example, such as why the stock shown online differed from the warehouse count, suits this role.

Follow-up

• How did you know they understood rather than just nodding?
• What did they decide, and would you have decided the same?
• What would you explain differently now?

Tell me about a time you disagreed with a technical decision made by a team member. How did you resolve it?

Medium · Behavioral and Problem-Solving

Approach

1. Choose a real technical disagreement, not a style nitpick: a synchronous call versus a queue, a schema choice, a library, a rollout plan. Make clear what was at risk if the wrong option shipped.
2. Show your method. You raised it privately or in a design review, and asked what problem their choice solved. You brought evidence: a benchmark, a prototype, an incident, or a written comparison of the options. You agreed on decision criteria before debating the answer.
3. Be honest about how it ended: your view won, theirs won, or a third option came out of the discussion. Disagree-and-commit is a good ending if you then helped their approach succeed.
4. Close with the result and how the working relationship went afterwards. The answer fails if your teammate comes across as the villain, or if you won only by escalating.

Follow-up

• Tell me about a time you were the one who turned out to be wrong.
• When would you escalate instead of settling it between the two of you?
• How did the decision hold up after release?

How do you handle ambiguity when project requirements are unclear or shifting?

Medium · Behavioral and Problem-Solving

Approach

1. Separate what is unknown from what nobody can know yet. List the open questions, name who can answer each one, and set a date by which each must be decided.
2. Write your assumptions down and get them acknowledged. Then build the smallest useful slice on those assumptions, so feedback comes from working software instead of a debate over the spec.
3. Design for the changes you expect. Keep rules that change often in configuration, wrap the part most likely to shift behind an interface, and delay irreversible steps (data migrations, external contracts) until the requirement settles.
4. Tell one story: the ambiguity, what you did first, what changed later, how much of your work survived the change, and what you would do sooner next time. Waiting for a complete spec, or building everything on a guess, both sink the answer.

Follow-up

• Requirements changed after you built it. What did you throw away?
• How do you decide you have asked enough and should start building?
• How did you keep stakeholders aligned while the requirements shifted?

What is your process for learning a new technology stack on the fly?

Medium · Behavioral and Problem-Solving

Approach

1. Describe a process you can repeat, then prove it with one example. Start from a real task you need to ship. Read the official architecture overview and getting-started guide. Then read the existing codebase and its tests to see how the team actually uses the stack.
2. Build a throwaway spike that exercises the risky parts (authentication, deployment, data access, error handling) before you touch production code. Keep notes as you go and turn them into a short internal guide.
3. Find the people who know the stack, do your homework before asking them specific questions, and have someone experienced in it review your first change.
4. Use an example close to this role, such as picking up a WMS or a cloud platform's services (Oracle Cloud Infrastructure is one of the reported topics). End with what you shipped, how quickly, and what you got wrong at first.

Follow-up

• What did you misunderstand at first, and how did you find out?
• How do you know you know enough to ship to production?
• How did you pass what you learned on to the team?