Huawei Interview Questions

What Huawei interviews focus on

Common Huawei interview questions

• Implement a function to find the longest substring without repeating characters.
  What a strong answer covers

  • Use a sliding window approach with two pointers (left, right) to maintain a window of unique characters.
  • Use a hashmap to store the last index of each character to detect repeats and adjust the left pointer.
  • Expand the right pointer and update the maximum length when no repeat; if repeat, move left pointer to last occurrence + 1.
  • Time complexity O(n) because each character is visited twice, space O(min(n, alphabet size)).

  View a sample answer

  The problem is solved using a sliding window. We maintain two pointers, left and right, representing the current window of non-repeating characters. A hashmap stores the most recent index of each character. As we iterate with the right pointer, if we encounter a character already in the hashmap and its index is within the current window (i.e., >= left), we move left to that index + 1 to exclude the duplicate. Then we update the hashmap with the current index and compute the window length. The maximum length encountered is the answer. This algorithm runs in O(n) time because each character is processed at most twice (by left and right), and O(min(m, n)) space where m is the character set size. Edge cases include empty string (return 0) and strings with all unique characters (return length).

  def length_of_longest_substring(s: str) -> int:
      """
      Find length of longest substring without repeating characters.
      Uses sliding window with hashmap to track last index of characters.
      """
      left = 0
      max_len = 0
      last_index = {}  # char -> last seen index
      
      for right, char in enumerate(s):
          # If character already seen and within current window, move left boundary
          if char in last_index and last_index[char] >= left:
              left = last_index[char] + 1
          # Update last index of character
          last_index[char] = right
          # Update max length
          max_len = max(max_len, right - left + 1)
      
      return max_len

• Describe the differences between TCP and UDP. When would you use each?
  What a strong answer covers

  • TCP is connection-oriented, reliable, ordered, and provides flow control; UDP is connectionless, unreliable, unordered, and has lower overhead.
  • TCP uses handshakes (SYN, SYN-ACK, ACK) to establish connections; UDP sends datagrams without setup.
  • TCP ensures data delivery via acknowledgments and retransmission; UDP does not guarantee delivery.
  • UDP is faster and suitable for real-time applications where some data loss is tolerable, e.g., streaming, gaming, DNS.

  View a sample answer

  TCP (Transmission Control Protocol) and UDP (User Datagram Protocol) are transport layer protocols, but they serve different purposes. TCP is connection-oriented, meaning it establishes a reliable, ordered, and error-checked connection between two hosts. It uses flow control and congestion avoidance mechanisms to manage data transmission, making it ideal for applications where data integrity and order matter, such as web browsing (HTTP), email (SMTP), and file transfers (FTP). TCP's overhead includes three-way handshake, acknowledgments, and retransmission of lost packets, which can introduce latency. UDP, on the other hand, is connectionless and unreliable; it sends independent datagrams without establishing a connection, acknowledgment, or ordering. This minimal overhead makes UDP fast and efficient, but it does not guarantee delivery, order, or error-free transmission. UDP is used in real-time applications like video streaming, online gaming, VoIP, and DNS queries, where occasional packet loss is acceptable and low latency is critical. In summary, choose TCP when reliability and order are paramount, and UDP when speed and low latency are more important than guaranteed delivery.

• Explain how you would design a distributed file storage system like HDFS.
  What a strong answer covers

  • HDFS follows a master/slave architecture with a single NameNode (master) managing metadata and multiple DataNodes (slaves) storing actual data blocks.
  • Files are split into blocks (default 128 MB) and replicated across DataNodes (default replication factor 3) for fault tolerance.
  • Data locality is leveraged to move computation to data rather than moving data to computation, improving performance.
  • Write pipeline: client writes to a primary DataNode, which replicates blocks serially to other DataNodes to ensure consistency.

  View a sample answer

  A distributed file storage system like HDFS (Hadoop Distributed File System) is designed to store large files across many commodity servers with high fault tolerance. The architecture consists of a single NameNode that manages the filesystem namespace, mapping file names to block IDs and tracking block locations, and multiple DataNodes that store data blocks. When a client writes a file, the NameNode assigns a set of DataNodes for each block; the client writes the block to the first DataNode, which then replicates it to subsequent DataNodes in a pipeline manner, ensuring data durability. Reading involves the client querying the NameNode for block locations, then reading directly from the nearest DataNode. Fault tolerance is achieved by block replication (typically 3 copies across different racks) and periodic heartbeat/block reports sent by DataNodes to the NameNode. If a DataNode fails, the NameNode detects the missing heartbeats and re-replicates the lost blocks. Scaling is done by adding more DataNodes, while the NameNode can become a bottleneck; thus, HDFS 2.x introduced a high-availability pair (Active/Standby NameNode). The system is optimized for large files and streaming access, not for low-latency random access.

• Tell me about a time you had a conflict with a team member. How did you resolve it?
  What a strong answer covers

  • I used the STAR method: Situation, Task, Action, Result.
  • Situation: During a sprint, two team members disagreed on using microservices vs monolithic refactoring for a new feature.
  • Task: As the tech lead, I needed to mediate and ensure a decision that met project deadlines and quality.
  • Action: I organized a meeting where each person presented pros/cons; we did a quick prototype and analyzed tradeoffs; finally, we agreed on a modular monolithic design with future extraction points.
  • Result: The team felt heard, delivered on time, and later successfully extracted one module into a microservice when needed.

  View a sample answer

  In a previous role, I faced a conflict between two senior developers about the architecture for a new feature: one advocated for microservices to improve scalability, while the other insisted on staying with the monolithic approach to avoid over-engineering. As the tech lead, I scheduled a structured meeting where each presented their arguments with data. We then built a small prototype for the critical path to evaluate both approaches. The prototype showed that microservices introduced unnecessary complexity for the current scope and would delay the release. We agreed on a modular monolithic design that allowed later extraction of specific components into microservices if needed. This decision satisfied both parties because it balanced pragmatism and future scalability. The project was delivered on schedule, and six months later we extracted one module into a microservice without significant refactoring. The conflict actually improved team collaboration, as we established a better decision-making process for future architectural discussions.

• Write code to reverse a linked list iteratively and recursively.
  What a strong answer covers

  • Iterative: use three pointers (prev, curr, next) to reverse links one by one. Time O(n), space O(1).
  • Recursive: reverse the rest of the list, then fix the last node. Base case: if head is None or head.next is None, return head.
  • In recursion, the new head is the last node; after reversing the sublist, point head.next.next = head and head.next = None.
  • Both approaches achieve O(n) time; iterative is usually preferred for space efficiency.

  View a sample answer

  Reversing a linked list is a classic problem. In the iterative approach, we maintain three pointers: previous (initially None), current (head), and next_node. We iterate through the list, pointing current.next to previous, then move previous and current forward. This modifies the list in-place with O(1) additional space. The recursive approach uses the call stack: the base case is when head or head.next is None, returning head. Otherwise, we recursively reverse the sublist starting from head.next. After recursion returns, the new head is the returned node. We then set head.next.next = head and head.next = None. While elegant, recursion uses O(n) stack space and may cause stack overflow for very long lists. Both methods run in O(n) time.

  class ListNode:
      def __init__(self, val=0, next=None):
          self.val = val
          self.next = next
  
  def reverse_list_iterative(head: ListNode) -> ListNode:
      """Reverse linked list iteratively using three pointers."""
      prev = None
      curr = head
      while curr:
          next_node = curr.next  # save next
          curr.next = prev       # reverse link
          prev = curr            # move prev forward
          curr = next_node       # move curr forward
      return prev  # new head
  
  def reverse_list_recursive(head: ListNode) -> ListNode:
      """Reverse linked list recursively."""
      # Base case: empty list or single node
      if not head or not head.next:
          return head
      new_head = reverse_list_recursive(head.next)
      head.next.next = head  # reverse the link
      head.next = None       # set old next to None
      return new_head

• How does a relational database index work? Describe B-tree vs hash index.
  What a strong answer covers

  • A database index is a data structure that speeds up query performance by allowing rapid lookup of rows based on column values.
  • B-tree indexes store data in a balanced tree structure, supporting efficient equality and range queries (e.g., BETWEEN, >, <).
  • Hash indexes use a hash function on the key to map to a bucket, providing O(1) lookups for equality queries but no support for range scans.
  • B-trees are the default in most relational databases (e.g., InnoDB uses B+tree); hash indexes are used in memory-based engines like MySQL MEMORY.

  View a sample answer

  A relational database index works like an index in a book: it provides a quick way to locate rows without scanning the entire table. The most common type is the B-tree index (or B+tree), which maintains a sorted tree structure. Nodes contain pointers to child nodes, and leaf nodes contain the actual data pointers. B-trees support both equality searches (e.g., WHERE id = 5) and range queries (e.g., WHERE age > 30) efficiently, with O(log n) time complexity. They also handle insertions and deletions gracefully without needing frequent reorganization. In contrast, hash indexes use a hash function to compute the address of the data bucket. They offer O(1) average time for equality lookups, but they cannot support range scans or partial prefix matches, and they are not ordered. Hash indexes are suitable only for exact-match queries and are often used in memory-optimized tables. When choosing, B-trees are versatile and appropriate for most workloads, especially with range conditions, while hash indexes excel in high-performance key-value lookups where range queries are not needed.

• Design a real-time chat system similar to WhatsApp. Discuss architecture, data storage, and scaling.
  What a strong answer covers

  • Use a client-server architecture with WebSocket for bidirectional, low-latency communication.
  • Message servers handle incoming messages, store them in a distributed database (e.g., Cassandra for high write throughput), and route them via message queues (e.g., Kafka) for async delivery.
  • Scaling: horizontally scale chat servers, shard databases by user/chat ID, use CDN for media files, and implement connection pooling and load balancers.
  • Fault tolerance: replicate chat servers, use distributed message brokers, and handle offline messages via persistent queues.

  View a sample answer

  A real-time chat system like WhatsApp requires a highly available, low-latency architecture. The core is a set of chat servers that maintain persistent WebSocket connections with clients. When a user sends a message, it goes to a chat server, which writes the message to a distributed, high-write-throughput database like Cassandra or HBase, partitioned by conversation ID to ensure fast reads. The chat server also pushes the message to the recipient(s) via their WebSocket connection. For offline users, messages are stored in the database and delivered when they come online, possibly using a push notification service (e.g., APNS/FCM). To handle millions of concurrent connections, we use a load balancer (e.g., HAProxy) distributing across multiple chat servers. For horizontal scaling, chat servers are stateless; state (connection info) is stored in a distributed cache like Redis. Media files (images, videos) are uploaded to a CDN or object storage (e.g., S3) and referenced by URLs. Message ordering is maintained using sequence numbers or timestamps with clock synchronization. The system's durability comes from replicating data across multiple data centers and using a pub/sub mechanism like Kafka to ensure messages are not lost. Overall, the design prioritizes low latency, high throughput, and availability through careful partitioning, replication, and caching.

• Describe a challenging project you led. What was your role and the outcome?
  What a strong answer covers

  • Project: Migrating a legacy monolith to a microservices architecture for a SaaS platform handling 10K+ requests per second.
  • My role: Lead engineer; responsible for system design, sprint planning, code reviews, and cross-team coordination.
  • Challenge: Breaking down the monolith while maintaining zero downtime and backward compatibility.
  • Action: Implemented strangler fig pattern, introduced an API gateway, and gradually routed traffic to new services.
  • Result: Migration completed in 4 months, latency reduced by 40%, and team improved deployment frequency from weekly to daily.

  View a sample answer

  One challenging project I led was migrating a legacy monolithic application to a microservices architecture for a high-traffic SaaS platform. The monolith had become a bottleneck, with deployments taking days and scaling issues as traffic grew. I was the lead engineer on a team of 10. The main challenges included ensuring zero downtime during migration and maintaining backward compatibility for existing clients. We adopted the strangler fig pattern: we built new services incrementally for specific functionalities (e.g., user management, billing) and used an API gateway to route traffic between old and new endpoints. I coordinated with product and QA to define clear interfaces and set up canary deployments. We also invested in CI/CD pipelines, containerization with Docker and Kubernetes, and comprehensive monitoring. The migration took four months, and we successfully decommissioned the monolith. Post-migration, system latency decreased by 40%, and we achieved daily deployments instead of weekly. The project also improved team morale because developers could work independently on smaller services. This experience taught me the importance of incremental progress, communication, and robust testing in large-scale refactoring.

Tips to prepare

• Review fundamental computer science topics thoroughly: data structures, algorithms, OS, and networking.
• Practice coding on a whiteboard or in a plain text editor without syntax highlighting.
• For system design, study large-scale systems like distributed databases, load balancers, and caching.
• Prepare specific examples of overcoming adversity or working under tight deadlines to demonstrate resilience.
• Research Huawei's corporate culture and values, especially concepts like 'wolf spirit' and dedication to customer success.

Frequently asked