← Walmart Interview InsightsSoftware Engineer

Walmart·Software Engineer·Onsite - System Design / Architecture·Senior

Senior
Jun 2026

Summary

System design round at Walmart Labs for a software engineer role. The whole session was basically one big question about building a multi-carrier shipping platform, and they went pretty deep on every layer of it.

Questions Asked (4)

Q1

Design a customer-facing package delivery service that integrates with multiple carriers like UPS, USPS, and FedEx. Walk through the full system: the customer API, how you abstract across carriers, rate shopping, label generation, tracking, and how you handle failures and scale.

System DesignAPI & IntegrationsTechnical Trade-offs
Author's notes

This is a monster of a question.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then design a layered architecture with a customer-facing API, a carrier abstraction layer, and core services for rate shopping, label generation, and tracking. Walk through each component, emphasizing how the abstraction layer normalizes differences across carriers, and discuss failure handling and scaling strategies.

Pro tip: Demonstrate awareness of real-world carrier API inconsistencies (e.g., different rate structures, label formats, and tracking statuses) and propose a canonical data model with adapters to isolate changes. Also, mention idempotency and retries with exponential backoff for carrier calls to handle transient failures.

1. Clarify Requirements and Scope

Ask questions to understand expected scale, supported carriers, delivery types, and SLAs. Define functional and non-functional requirements such as rate shopping, label generation, tracking, and fault tolerance.

2. Design High-Level Architecture

Outline the main components: customer API, carrier abstraction layer, rate shopping service, label service, tracking service, and data stores. Explain how they interact and the flow for key operations.

3. Detail Carrier Abstraction and Integration

Describe how to abstract carrier-specific APIs using adapters and a canonical data model. Discuss normalization of rates, labels, and tracking events, and how to handle carrier-specific quirks.

4. Address Failure Handling and Resilience

Explain strategies for handling carrier outages, timeouts, and errors: retries with backoff, circuit breakers, fallback carriers, idempotency, and dead-letter queues. Also cover data consistency and reconciliation.

5. Discuss Scaling and Performance

Cover horizontal scaling of services, caching of rates and tracking data, asynchronous processing for label generation, and database sharding or partitioning. Mention monitoring, alerting, and capacity planning.

Key Points to Mention

  • Canonical data model and adapter pattern for carrier abstraction
  • Rate shopping: parallel calls to carriers, caching, and fallback logic
  • Label generation: asynchronous processing, idempotency, and storage of labels
  • Tracking: polling vs. webhooks, event normalization, and real-time updates
  • Failure handling: retries, circuit breakers, dead-letter queues, and idempotency keys
  • Scaling: horizontal scaling, caching, sharding, and monitoring

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q2

How would you normalize tracking events across carriers that use completely different status codes and event schemas?

System DesignAPI & IntegrationsData Modeling
Author's notes

Blanked for a second here.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by acknowledging the challenge of heterogeneous carrier schemas and propose a canonical event model with a normalization layer. Then walk through the design: ingestion, mapping, enrichment, and storage, emphasizing idempotency and extensibility. Conclude with how you'd handle edge cases and monitor data quality.

Pro tip: Mention that you'd version the canonical schema and mappings to avoid breaking changes when carriers update their APIs. Also, highlight the importance of a dead-letter queue for unmapped events to prevent data loss and enable manual review.

1. Define a canonical event model

Identify the core attributes common across carriers (e.g., tracking number, status, timestamp, location) and define a unified schema with clear semantics and enumerations.

2. Build a normalization layer

Implement per-carrier adapters that transform raw carrier events into the canonical model, using configuration-driven mappings where possible to reduce code changes.

3. Ensure idempotent and ordered processing

Use unique event IDs and deduplication logic to handle retries, and design for out-of-order events by using timestamps or sequence numbers.

4. Enrich and validate

Add derived fields (e.g., normalized status categories) and validate events against the canonical schema, routing invalid events to a dead-letter queue for analysis.

5. Monitor and evolve

Set up metrics for mapping success rates and latency, and version the schema and mappings to support new carrier updates without breaking existing consumers.

Key Points to Mention

  • Canonical data model with clear status enums and required fields
  • Adapter pattern or strategy pattern for per-carrier transformation
  • Configuration-driven mappings to reduce code changes
  • Idempotency and deduplication using unique event identifiers
  • Dead-letter queue for unmapped or invalid events
  • Schema versioning and backward compatibility
  • Monitoring and alerting on normalization failures

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q3

A carrier API goes down mid-operation. How do you handle retries and partial failures without creating duplicate shipments or charges?

System DesignTechnical Trade-offsAPI & Integrations
Author's notes

This is where idempotency came back up.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by acknowledging the need for idempotency and a state machine to track operations. Then describe a retry strategy with exponential backoff and jitter, and how to handle partial failures by reconciling with the carrier's API. Emphasize that preventing duplicates requires unique idempotency keys and careful handling of timeouts.

Pro tip: Mention that you'd implement a 'reconciliation' process that periodically checks the carrier's system for shipments that may have been created but not acknowledged, and use that to resolve inconsistencies. This shows you think beyond immediate retries and consider eventual consistency.

1. Ensure Idempotency

Use unique idempotency keys for each shipment request so that retries don't create duplicates. The carrier should support idempotent operations, but if not, maintain a local record of requests and responses.

2. Implement Retry Logic with Backoff

Retry failed requests with exponential backoff and jitter to avoid overwhelming the carrier. Set a maximum retry limit and consider circuit breakers to prevent cascading failures.

3. Handle Partial Failures

If a request times out, don't assume failure; the shipment might have been created. Query the carrier's API (if available) to check the status before retrying. If not, log the ambiguity and reconcile later.

4. Reconciliation Process

Implement a periodic reconciliation job that compares local shipment records with the carrier's records to detect and resolve discrepancies, such as duplicate shipments or missing charges.

5. Monitor and Alert

Set up monitoring for retry rates, failure rates, and reconciliation outcomes. Alert on anomalies so the team can intervene quickly.

Key Points to Mention

  • Idempotency keys and their role in preventing duplicate shipments
  • Exponential backoff with jitter for retries
  • Circuit breaker pattern to avoid cascading failures
  • Reconciliation with the carrier's system to resolve partial failures
  • State machine or saga pattern to track operation status
  • Monitoring and alerting for retry and failure metrics

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q4

How would you approach observability for this system, specifically around carrier reliability and shipment lifecycle?

System DesignProduct Analytics & Metrics
Author's notes

Pretty short discussion on this one.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the system's scope and key components, then define observability goals around carrier reliability and shipment lifecycle. Structure your answer around the three pillars of observability (metrics, logs, traces) and how they apply to each stage of the shipment lifecycle and carrier interactions. Emphasize actionable metrics, alerting, and continuous improvement.

Pro tip: Tie observability directly to business outcomes like on-time delivery rate and cost per shipment, and mention how you'd use data to drive carrier scorecards and SLA enforcement. This shows you understand both technical and business impact.

1. Clarify system and goals

Ask questions to understand the system architecture, key components, and what 'carrier reliability' and 'shipment lifecycle' mean in this context. Define observability goals aligned with business KPIs.

2. Identify key events and metrics

Map out the shipment lifecycle stages (e.g., order placed, picked up, in transit, out for delivery, delivered) and define metrics for each stage, such as latency, success rate, and error rate. For carrier reliability, include metrics like on-time pickup/delivery, damage rate, and cost.

3. Instrument with the three pillars

Implement logging for detailed event tracking, metrics for quantitative monitoring, and distributed tracing to follow a shipment across services and carriers. Ensure context propagation for end-to-end visibility.

4. Set up monitoring and alerting

Create dashboards for real-time visibility and define alerts for anomalies or SLA breaches. Use thresholds and anomaly detection to proactively identify issues.

5. Iterate and improve

Use observability data to perform root cause analysis, optimize carrier selection, and improve processes. Establish feedback loops with carriers and internal teams.

Key Points to Mention

  • Define SLIs/SLOs for carrier reliability (e.g., on-time delivery percentage) and shipment lifecycle stages.
  • Use distributed tracing to track shipments across multiple services and external carriers.
  • Implement structured logging with correlation IDs for end-to-end traceability.
  • Monitor key business metrics like cost per shipment, delivery time, and exception rates.
  • Set up alerts for SLA violations and anomalies, with escalation paths.
  • Leverage observability data for carrier scorecards and continuous improvement.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.