JD.com Interview Questions

What JD.com interviews focus on

Common JD.com interview questions

• Implement a function to serialize and deserialize a binary tree (LeetCode 297).
  What a strong answer covers

  • Use preorder traversal for serialization; include markers for null nodes.
  • Deserialize by recursively building tree from the serialized list using a queue or index.
  • Time complexity: O(n) for both operations; space complexity: O(n) for serialized string.
  • Handle edge cases: empty tree, large input, non-unique values.

  View a sample answer

  To serialize a binary tree, we can use a preorder traversal and represent null nodes with a special marker (e.g., '#'). We traverse the tree recursively, appending node values (or marker) separated by commas. For deserialization, we split the serialized string into a list, and use a recursive function that builds the tree by consuming elements from the list (using an index or a queue). Since serialization and deserialization both visit each node exactly once, time complexity is O(n), and space complexity is O(n) for storing the serialized string and recursion stack. We should handle edge cases like an empty tree (empty string) and ensure the marker doesn't conflict with actual node values. A pitfall is using a non-local variable for index in deserialization, which requires careful management. Using a queue can simplify but increase memory slightly. This approach works for any binary tree, including unbalanced ones.

  class Codec:
      def serialize(self, root):
          """Encodes a tree to a single string."""
          def preorder(node):
              if not node:
                  vals.append('#')
              else:
                  vals.append(str(node.val))
                  preorder(node.left)
                  preorder(node.right)
          vals = []
          preorder(root)
          return ','.join(vals)
  
      def deserialize(self, data):
          """Decodes your encoded data to tree."""
          def build():
              val = next(vals)
              if val == '#':
                  return None
              node = TreeNode(int(val))
              node.left = build()
              node.right = build()
              return node
          vals = iter(data.split(','))
          return build()

• Design a distributed order processing system that handles millions of transactions per day.
  What a strong answer covers

  • Use event-driven architecture with message queues (Kafka) for decoupling order ingestion from processing.
  • Order service is stateful; use database sharding by order_id to distribute load.
  • Implement idempotency keys to handle duplicate events; use two-phase commit or saga pattern for consistency.
  • Scale horizontally with stateless services, auto-scaling groups, and CDN for static assets.
  • Monitor with distributed tracing (Jaeger) and metrics (Prometheus) for visibility.

  View a sample answer

  For a distributed order processing system handling millions of transactions per day, we need high throughput, low latency, and strong consistency. The system should be decomposed into microservices: Order Service, Payment Service, Inventory Service, Notification Service, etc. Orders are ingested via REST or gRPC endpoints behind a load balancer. We use Apache Kafka as a message queue to decouple ingestion from processing; each order event is published to a partitioned topic. The Order Service maintains state in a sharded database (e.g., CockroachDB or MySQL with sharding by order_id). To ensure exactly-once processing, we implement idempotency keys. For transactions spanning multiple services, we can use the Saga pattern for eventual consistency, or two-phase commit for strong consistency if needed. We cache hot data (e.g., inventory status) in Redis. Services are stateless and scaled horizontally using Kubernetes. Monitoring is crucial: distributed tracing with Jaeger, metrics with Prometheus, and alerts with Grafana. A pitfall is over-engineering; start with simpler sharding and evolve. Network latency can be reduced by colocating services. Database joins should be avoided; use denormalization or event sourcing.

• Describe a time you had to make a trade-off between speed and quality in a project. How did you decide?
  What a strong answer covers

  • Use STAR method: Situation, Task, Action, Result.
  • Situation: Tight deadline with critical feature delivery.
  • Task: Need to release a payment integration for a client; quality must be secure and reliable.
  • Action: Implemented core functionality first, deferred non-critical UI polish, and added extra testing for failure scenarios.
  • Result: Delivered on time with no production issues; quality sacrificed was minor UX enhancements.

  View a sample answer

  In a previous role, we were developing a payment module for a major client with a fixed release date. The situation was that we had a tight two-week deadline, but the team was also responsible for maintaining other features. The task was to deliver a secure and reliable payment integration; quality was paramount for financial transactions. I had to decide between implementing all planned features or cutting scope to ensure robustness. I chose to prioritize the core transaction flow and error handling, while deferring cosmetic UI improvements and advanced reporting. We focused extra effort on testing edge cases like network failures and duplicate payments. As a result, we launched on time with zero production incidents. The trade-off was acceptable because the deferred features were low-risk and could be added later without affecting functionality. This experience taught me to assess risk versus value when making such decisions.

• Given a list of intervals, merge all overlapping intervals (LeetCode 56).
  What a strong answer covers

  • Sort intervals by start time; then iterate and merge overlapping ones.
  • Maintain a current interval; if next.start <= current.end, merge (update end to max).
  • Time complexity: O(n log n) due to sorting; space: O(n) for output.
  • Edge cases: empty input, single interval, intervals with same start, fully contained intervals.

  View a sample answer

  To merge overlapping intervals, we first sort the intervals by their start times. Then we initialize an empty result list and iterate through sorted intervals. For each interval, if the result list is empty or the current interval's start is greater than the last interval's end, we append the current interval as a new entry. Otherwise, we merge by updating the last interval's end to the maximum of its own end and the current interval's end. Sorting takes O(n log n) time, and the merge pass is O(n), so overall O(n log n) time. Space is O(n) for the output. Edge cases include empty input (return empty list), single interval (return as is), intervals that are exactly adjacent (e.g., [1,2] and [2,3] should merge if we consider overlapping inclusive, but problem usually defines overlapping as touching? Typically they merge if start <= end, so [1,2] and [2,3] merge. Check problem statement: LeetCode 56 merges if intervals overlap, and overlapping includes touching? Usually yes, because they compare current.end >= next.start. So we merge. For intervals with same start, we take the max end. The algorithm is straightforward but careful with inclusive vs exclusive boundaries.

• Design a real-time logistics tracking system for JD's delivery network.
  What a strong answer covers

  • Use GPS devices, IoT sensors, and mobile apps for real-time location updates.
  • Ingest location data via Kafka streams; process with Apache Flink for geofencing and ETA calculations.
  • Store trajectory data in a time-series database (e.g., InfluxDB) and shipment state in a relational database.
  • Expose APIs for tracking, with WebSocket push for live updates to customers.
  • Scale by partitioning by region, using CDN for static tracking pages, and implementing caching for frequent queries.

  View a sample answer

  For JD's real-time logistics tracking system, we need to handle millions of delivery vehicles and packages across China. The system captures location updates from GPS devices on trucks and courier mobile apps. These events are streamed via Kafka (partitioned by region for ordering). A stream processing engine like Apache Flink consumes the events, enriches them (e.g., geofence matching, ETA calculation using traffic data), and stores the current location in a fast key-value store (Redis) for low-latency reads. Historical trajectory data is stored in a time-series database (e.g., InfluxDB) aggregated by minute. Shipment state (e.g., picked up, in transit, delivered) is maintained in a relational database (MySQL sharded by order_id). For customer-facing tracking, we provide REST APIs for polling and WebSocket connections for live updates (using a pub/sub layer like Redis Pub/Sub or Kafka). To scale, we partition processing by geographic region; each region has its own Flink jobs and database shards. We use CDN for static tracking pages and cache frequent queries with Redis. Latency should be under a few seconds. A pitfall is handling GPS drift and network loss; we use smoothing filters and allow offline messages with timestamps. Security is critical: authenticate APIs and encrypt location data.

• How would you optimize a database query that's slow due to joins on large tables?
  What a strong answer covers

  • Identify the query: use EXPLAIN to understand execution plan.
  • Check indexes: ensure join columns and WHERE conditions are indexed.
  • Consider denormalization: reduce joins by storing redundant data or using summary tables.
  • Rewrite query: use subqueries or common table expressions (CTEs) to simplify, or partition tables.
  • Use caching: cache query results in Redis or in application layer for repeatable queries.

  View a sample answer

  When a database query is slow due to joins on large tables, the first step is to analyze the execution plan using EXPLAIN in MySQL/PostgreSQL. Look for full table scans and high row estimates. The most common fix is to ensure that columns used in joins and WHERE clauses are indexed. For a join condition like ON a.id = b.foreign_id, both columns should have indexes. If the indexes exist but the query is still slow, consider covering indexes (include all selected columns) to avoid additional lookups. Another approach is to denormalize: store frequently joined data in one table (e.g., pre-join computed columns) or create summary tables for aggregation queries. If the query is used rarely, caching the result in Redis can reduce load. For extremely large tables, partitioning by date or region can improve performance by pruning irrelevant partitions. Also, rewriting the query to use subqueries or CTEs that reduce the result set before joining can help. For example, filter each table aggressively before joining. Avoid functions on indexed columns in WHERE (e.g., WHERE YEAR(date) = 2020) as they disable index usage. Ultimately, the solution depends on the specific workload; iterate with EXPLAIN after each change.

• Tell me about a project where you had to collaborate across teams. What was the outcome?
  What a strong answer covers

  • Use STAR: Situation, Task, Action, Result.
  • Situation: Cross-team project to revamp recommendation system at an e-commerce company.
  • Task: Data engineering team needed to provide real-time user behavior data to ML team.
  • Action: Organized weekly syncs, defined data contracts, built a streaming pipeline with Kafka, and created automated validation.
  • Result: Delivered on schedule, model performance improved by 15%, and established a template for future cross-team collaborations.

  View a sample answer

  At my previous company, we undertook a project to revamp the product recommendation system, which required close collaboration between the data engineering team (my team) and the machine learning team. The situation was that the existing batch-based pipeline caused latency in recommendations. The task was to build a real-time streaming pipeline that feeds user clickstream data to the ML models. I took the initiative to facilitate weekly sync meetings with both teams to align on requirements and data schemas. We defined clear data contracts (e.g., event formats, delivery guarantees) and built an event-driven pipeline using Kafka and Flink. I also implemented automated data quality checks to catch anomalies early. As a result, the pipeline was delivered on schedule, the ML models used fresher data, leading to a 15% lift in click-through rates. Additionally, the collaboration framework we established became a template for other cross-team projects. The key was transparent communication and shared ownership of deliverables.

• Implement a cache with LRU eviction policy (LeetCode 146).
  What a strong answer covers

  • Use a doubly linked list with a hash map: O(1) get and put operations.
  • Maintain a dummy head and tail for easy node insertion/removal.
  • On access (get/put), move accessed node to head (most recent).
  • On put, if key exists, update and move to head; if size exceeds capacity, remove node before tail.
  • Time complexity: O(1); space: O(capacity).

  View a sample answer

  The LRU (Least Recently Used) cache eviction policy keeps the most recently used items at the front and evicts the least recently used items from the back when capacity is exceeded. To implement LRU cache with O(1) operations, we combine a hash map (dictionary) for fast key lookup with a doubly linked list for maintaining order. The hash map stores the mapping from key to the corresponding node in the linked list. The doubly linked list has dummy head and tail nodes to simplify insertion and removal. For get(key): if key exists, we move the corresponding node to the head (i.e., remove from current position and add to front) and return the value; else return -1. For put(key, value): if key exists, update the node's value and move it to head; if not, create a new node and add to head, then if size exceeds capacity, remove the node before the dummy tail (LRU element) and delete its key from hash map. This ensures all operations are O(1). Edge cases include capacity 0 (return -1 for gets) and handling duplicate keys. Memory usage is O(capacity). A pitfall is forgetting to update the hash map when moving nodes. The implementation requires careful pointer management.

Tips to prepare

• Practice coding on a whiteboard or plain text editor—JD.com often uses in-person coding sessions without autocomplete.
• Review JD.com's business and latest tech news, especially around logistics automation, cloud (JD Cloud), and retail tech.
• Prepare to explain your thought process in both Chinese and English, as interviews may switch between languages.
• Focus on scalability and fault tolerance when designing systems—JD.com deals with peak loads like Singles' Day.
• Have concrete examples ready for behavioral questions that highlight initiative, problem-solving, and alignment with JD's values.

Frequently asked