Huawei Java Developer Campus Interview: Complete Guide from Online Test to Offer

Background

I'm a fresh graduate from a top-tier university with a degree in Software Engineering. I decided to pursue Java backend development during my junior year and had one internship at a mid-sized internet company as a Java developer. The IBM campus recruitment was my top priority during the fall hiring season — after all, IBM's compensation and platform are among the best in the industry, and I knew several seniors who worked there, so I had some inside knowledge beforehand.

IBM's campus recruitment process is quite unique compared to most tech companies. They require an online coding test before interviews. I submitted my resume in September for the Java Developer position, and the entire process from the online test to receiving the offer took about a month and a half. Honestly, the waiting was agonizing — especially waiting for the online test results. I was checking forums every day reading other people's interview experiences.

Let me walk through the entire process in detail, hoping it helps those preparing for IBM's campus recruitment.

Interview Process Breakdown

Online Coding Test (3 Problems, 2 Hours)

The online test is the first mandatory hurdle. Three problems worth a total of 600 points, and you generally need at least 150 points to get an interview opportunity (requirements vary by department — some require 200+). The test uses IBM's own platform, supporting Java, C++, Python, and other languages.

Problem 1 (100 points): String Processing

The problem asked to count occurrences of a pattern in a string. This was straightforward — I used String's indexOf method in a loop and solved it in about 15 minutes.

Problem 2 (200 points): Sliding Window

Given an array and window size, find the maximum value in each sliding window. This is essentially LeetCode 239, which I had practiced before. I used a deque to solve it. However, I was a bit nervous during the test and had a small bug that took about 10 minutes to debug.

Problem 3 (300 points): Dynamic Programming

A path-planning problem, similar to a variant of LeetCode's Unique Paths but with obstacles and weights. I only got partial credit on this one, passing about 60% of test cases. My DP state transition equation wasn't clear enough, and I didn't handle boundary conditions well.

My final score was around 400 points, which was enough to advance to the interview stage.

Technical Round 1 (About 50 Minutes)

The first round was an on-site interview at the IBM campus. The interviewer was a senior engineer in his thirties, very approachable.

Java Fundamentals:

The interviewer started with Java basics, asking in great detail.

1. HashMap's underlying implementation? I described the JDK 1.8 structure of array + linked list + red-black tree, along with the resizing mechanism and load factor. The interviewer followed up on why HashMap is not thread-safe — I explained that concurrent puts could cause data overwriting, and in JDK 1.7, concurrent resizing could cause linked list cycles.

2. ConcurrentHashMap's implementation? I described JDK 1.8's CAS + synchronized approach, where each bucket in the Node array is locked with synchronized, providing finer granularity than JDK 1.7's Segment-based locking.

3. JVM memory model? I covered both thread-private areas (program counter, VM stack, native method stack) and thread-shared areas (heap, method area). The interviewer followed up on garbage collection algorithms, and I described mark-sweep, mark-compact, copying algorithms, and generational collection theory.

4. The volatile keyword? I explained that it ensures visibility and prevents instruction reordering, and mentioned the happens-before principle. When asked if volatile guarantees atomicity, I said no and gave the i++ example.

Project Discussion:

The interviewer asked about my internship project. I focused on the Spring Boot + MyBatis architecture and how we used Redis for caching optimization. He followed up on solutions for cache penetration and cache avalanche — I mentioned Bloom filters and random expiration times, respectively.

Coding:

The interviewer asked me to implement a DCL (Double-Checked Locking) singleton. I wrote it but forgot to add volatile — the interviewer pointed this out. Important note: DCL singletons must use volatile, otherwise instruction reordering could result in getting an uninitialized object.

Technical Round 2 (About 60 Minutes)

The second-round interviewer was more senior, and the questions leaned more toward architecture and system design.

Spring:

1. Spring IOC principles? I started from BeanDefinition parsing, described the complete Bean lifecycle of instantiation, property injection, and initialization, and mentioned the three-level cache for resolving circular dependencies.

2. Spring AOP implementation? I explained the differences between JDK dynamic proxies and CGLIB proxies, and Spring's default selection strategy (JDK proxy when interfaces exist, CGLIB otherwise).

3. Spring Boot auto-configuration principles? I described how @EnableAutoConfiguration uses SpringFactoriesLoader to load configuration classes from META-INF/spring.factories, then filters them based on conditional annotations.

Database:

1. MySQL index underlying data structure? I described B+ trees and their advantages over B trees: leaf nodes form linked lists for efficient range queries, and non-leaf nodes only store keys, allowing more keys per node and reducing tree height.

2. Transaction isolation levels? I described read uncommitted, read committed, repeatable read, and serializable, along with the problems each level might have (dirty reads, non-repeatable reads, phantom reads). The interviewer asked about MySQL's default isolation level — I said repeatable read and explained MVCC implementation.

3. How to optimize slow queries? I mentioned examining execution plans, adding indexes, avoiding full table scans, and reducing lookups.

System Design:

The interviewer gave a scenario: design a URL shortening service. I covered ID generation for short codes, database storage for mappings, cache-accelerated lookups, and 301/302 redirect selection. When asked how to ensure ID uniqueness under high concurrency, I suggested using Snowflake algorithm or Redis increment.

HR Round (About 20 Minutes)

The HR round was relatively relaxed, covering these questions:

1. Why did you choose IBM?

2. What was your biggest setback? How did you overcome it?

3. What's your view on overtime?

4. What's your expected salary?

5. Do you have other offers?

I had prepared for all of these in advance and answered naturally. Regarding overtime, I didn't say I was unwilling — instead, I said I could accept overtime when the project requires it, but I'd also focus on improving work efficiency. About other offers, I honestly said I was waiting for results from a few other companies.

Complete Question List

1. HashMap underlying implementation and thread safety issues

2. ConcurrentHashMap implementation principles

3. JVM memory model and garbage collection algorithms

4. volatile keyword's role and atomicity issues

5. Singleton pattern DCL implementation (hand-written)

6. Spring IOC principles and three-level cache

7. Spring AOP's JDK dynamic proxy and CGLIB

8. Spring Boot auto-configuration principles

9. MySQL B+ tree index structure

10. Transaction isolation levels and MVCC

11. Slow query optimization strategies

12. URL shortening service system design

13. Online test: string processing, sliding window maximum, DP path planning

Key Takeaways

1. Practice coding problems before the online test. IBM's online test isn't extremely difficult, but without preparation, it's easy to stumble on the second and third problems. I recommend at least completing LeetCode's Hot 100, focusing on strings, sliding windows, and dynamic programming. Higher test scores give you more leverage in subsequent interviews.

2. Systematically review Java fundamentals. IBM's coverage of Java basics is very comprehensive — from collections frameworks to concurrent programming to JVM, almost every module comes up. I recommend systematic review using "The Art of Java Concurrent Programming" and "Understanding the JVM" rather than just reading interview question compilations.

3. Understand Spring ecosystem principles. Don't just know how to write CRUD with Spring Boot — understand the underlying principles of IOC, AOP, and auto-configuration. Interviewers value whether you understand the "why" behind the "what."

4. Don't neglect database knowledge. MySQL indexes, transactions, and locks are high-frequency topics. I recommend going through the core chapters of "High Performance MySQL." Combining optimization experience from real projects during the interview earns major bonus points.

5. Don't take the HR round lightly. Many people think the HR round is just a formality, but IBM's HR round does involve screening. Answer questions sincerely but mind your boundaries, especially on sensitive topics like overtime and salary.

6. Be patient throughout the process. IBM's campus recruitment process is quite long — it can take over a month from resume submission to offer. There may be long periods without updates. Don't panic — just wait patiently.

FAQ

Q: How many points do you need to pass the online test?

A: Generally, 150+ points gives you an interview opportunity, but requirements vary by department. I recommend aiming for 200+ to be safe.

Q: What language should I use for the online test?

A: If you're applying for a Java position, I recommend using Java. While Python is faster to write, interviewers may look at your coding style.

Q: Are interviews online or on-site?

A: Mine was on-site at the IBM campus. Different batches may vary — check your notification.

Q: Does the second technical round ask algorithm questions?

A: My second round didn't have standalone algorithm problems, but the system design section tests your logical thinking, which is essentially algorithmic thinking in disguise.

Q: Can the HR round reject candidates?

A: Yes. While the pass rate is relatively high, extremely poor performance or clearly misaligned values can still lead to rejection. Take every round seriously.