Comprehensive Interview Experience Summary and Preparation Guide for Major Tech Companies

Recently I surveyed the job market and compiled this guide to help readers.

Battle Status

Beike : one technical round, self‑rejected.

Maimai : two technical rounds, self‑rejected.

Genshuixue : three technical rounds + one HR round.

Sohu : three technical rounds + one HR round.

Xiaomi : three technical rounds + one HR round.

Baidu : two technical rounds in the same department, different teams, self‑rejected.

Meituan : two departments, each with two technical rounds and one HR round.

ByteDance : three technical rounds, self‑rejected.

Kuaishou : three technical rounds + one HR round.

The overall interview window is 4.15 ~ 5.15 , including the May Day holiday. I prefer companies with a relatively fast interview cycle because I am anxious and do not want a prolonged process.

Personal Profile

Education : Non‑top undergraduate and master’s in Automation & Control Theory, not a formal CS background.

Current Position : Research institute of a Beijing fintech company, previously worked on AI; now mainly big data + Java development.

Previous Interviews : This is my second job change; the first was in 2017 when I only received a JD offer. I never got an interview from BATTMD.

Key Points

Practice : LeetCode Chinese site + Niuke + Microsoft Xiao Pang Ge + codetop (https://codetop.cc). Most interview coding questions come from Niuke.

Resume : Avoid typos, keep project descriptions organized, highlight core responsibilities, rehearse your pitch, and only list a skill if you can explain it thoroughly.

Post‑Interview Review : Record interviewers' focus points; interviews are often enjoyable because senior engineers tend to match your knowledge level.

Preparation Strategy : Start with a few companies to get familiar with the process before targeting your dream firms.

Timeline Management : Follow up with recruiters or HR promptly after each round; if a company doesn’t work out, move on to the next.

Interview Evaluation : Carefully choose the companies you apply to; large firms often keep detailed interview notes that affect future opportunities.

Interview Experiences

1. Beike

First Round

LeetCode 199 – Binary Tree Right Side View.

Explain differences between Dubbo and Spring Cloud from macro to micro level.

Difference between token bucket and leaky bucket rate‑limiting; role of Zuul.

Project details, flow diagram, bottlenecks.

How to locate a dead‑loop bug after release.

QPS, load testing, performance metrics.

Performance optimization experience.

Thread pool reliability when 20% of tasks may fail – guarantee 100% success.

Why I switched from algorithm work to knowledge‑graph engineering.

Current position is pure Cloud development – my disadvantages.

Comparison of graph databases (Neo4j, DGraph, GanusGraph).

Mis‑match of direction – rejected.

2. Genshuixue

First Round

LeetCode 662 – Diameter of Binary Tree.

Design a flash‑sale scenario and walk through the solution.

Project details, scaling data volume and concurrency tenfold, identify performance bottlenecks.

Message middleware – guarantee no loss, ordering; why Kafka is fast; Kafka rebalancing.

Mindset shift from B‑to‑C role, stress handling.

Discuss Spring Cloud pressure points.

Second Round

MySQL – transaction isolation, MVCC, three log files.

Data concurrency and business complexity discussion.

Self‑presentation of a satisfying project and its highlights.

Operating system concepts: blocking, non‑blocking, sync, async, BIO, NIO, AIO.

Daily self‑learning methods.

LeetCode 215 – Top K.

Third Round

Project introduction – interviewers were busy, limited deep questions.

Redis & MySQL cache consistency.

Understanding of Dubbo internals.

Understanding of DDD.

3. Sohu

First Round

What is MapJoin ?

Hive data skew handling.

Difference between cluster by, order by, reduce by, distribute by .

Why Kafka is fast.

MySQL B‑tree vs B+‑tree.

UDF, Spark, Netty, BIO, NIO, AIO frameworks.

LeetCode 103 – Zigzag Level Order Traversal.

Second Round

Project overview, framework diagram, responsibilities, data governance practice.

MapReduce flow, shuffle details, avoiding data skew.

Hive SQL, window functions.

ZooKeeper concepts, distributed transaction models (2PC, 3PC, TCC, Paxos).

Self‑introduction of projects and career planning.

LeetCode 5 – Longest Palindromic Substring.

Third Round

Project overview, module responsibilities.

HBase architecture, LSM tree understanding.

Spark usage in daily work.

Scala vs Java differences.

Job responsibilities for the applied position.

4. Maimai

First Round

MySQL query optimization.

MySQL ACID principles and underlying architecture.

Redis basic data types and implementation.

RabbitMQ modes, guaranteeing order and no loss.

Advanced Linux commands (tmux, awk, etc.).

Why MySQL Text type is discouraged.

Optimization of LIMIT 100000 using covering indexes.

Diagnosing CPU saturation on Linux.

1. top -c shows process list
2. Press uppercase P to sort by CPU, find PID = 10765
3. top -Hp 10765 shows thread list
4. Press uppercase P again to sort threads, find thread PID = 10804
5. Convert PID 10804 to hex: printf "%x" 10804 => 2a34
6. jstack 10765 | grep '0x2a34' -C9  # -C shows 9 lines context
7. Identify the high‑CPU thread name and its activity

9. Detect if a linked list has a cycle, find the entry point, and compute the cycle length.

10. Find the longest substring without repeating characters.

11. Design a data model for a post with back‑and‑forth replies.

Second Round

Given 100 000 numbers ranging 0‑100, count pairs that sum to 100.

Distributed lock implementation strategies.

Why Redis is fast and its underlying implementation.

TTL in RabbitMQ.

Redis cluster deployment issues and performance troubleshooting.

Whether a pure Python backend role is acceptable and discuss current vs expected compensation.

5. Xiaomi

First Round

Longest common subsequence and longest common substring for two strings.

Understanding of HBase and LSM evolution.

Project description focusing on data governance.

SQL basics, MySQL indexes and optimization.

Kafka rebalancing, architecture, read/write flow.

Second Round

Top‑K problem on LeetCode.

Project presentation, bottlenecks, self‑review.

Understanding of Spring, circular dependencies.

Online MySQL column modification without downtime and server scaling.

RabbitMQ vs Kafka comparison.

Find the second most frequent string in 1 GB memory with 1 TB file.

Inter‑process communication methods and trade‑offs.

Third Round

Project presentation.

Discussion of algorithmic projects, learning from statistical learning, machine‑learning books.

How to compute total volume of all lakes and oceans (math modeling).

Kernel vs user‑mode concepts, scheduling algorithms.

Implement string reversal (e.g., "I LOVE C++" → "C++ LOVE I").

Job responsibilities discussion.

6. Baidu

First Round

How to solve TCP blocking.

Understanding of Python GIL.

Production‑grade Flask configuration and session validation.

Python inheritance features.

Design differences between Java HashMap JDK7 and JDK8, why loops appear in JDK7.

Java thread‑pool parameters.

Understanding of synchronized.

Advantages and usage of ReentrantLock.

Fair vs non‑fair lock selection criteria.

Redis transactions.

Redis ZSet internals.

Redis I/O multiplexing.

Why Kafka is fast, consumer groups, rebalancing.

MySQL isolation levels and MVCC.

Most challenging recent project.

Spring AOP principles and implementation via reflection.

LeetCode 572 – Determine if one binary tree is a subtree of another.

Feedback that the role was not a perfect match but the interview felt smooth.

First Round (duplicate heading in source)

Swap left and right nodes of a binary tree – provide solution and test cases.

Merge intervals – provide solution and test cases.

Merge multiple linked lists – provide solution and test cases.

HBase architecture and LSM understanding.

Understanding of ClickHouse and Spark.

Interviewer never turned on video, mistakenly thought I had only one year of experience.

Feedback that the role was not a perfect match, felt like KPI filtering.

7. Meituan

First Round

Graph engine knowledge – discuss Dgraph, JanusGraph.

Project discussion and technical challenges.

Understanding of high concurrency .

Convert binary tree to doubly linked list (Offer 36).

JVM garbage collectors – CMS pros/cons, three‑color marking, G1 pros/cons and implementation.

HashMap vs ConcurrentHashMap differences and thread‑safety issues.

Hive execution internals.

Second Round

Relationship between Yanjing University and my alma mater.

Process A writes variable x to disk; can Process B operate on it?

Design a model similar to 360’s nationwide defense – normal distribution, periodic model updates.

TCP knowledge points.

Front‑end request flow from sending to receiving response.

Design a data structure supporting O(1) insert, remove, random.

First Round (additional)

Because the previous second‑round interviewer thought the role mismatched, I was referred to another department; the earlier two rounds went well, so this time there was no third round.

Self‑introduction, project architecture, improvements if you could redo the project.

Project data details.

Compare RabbitMQ and Kafka, explain your understanding of message queues.

How mmap works in Java, evolution of ZeroCopy.

How online services ensure stability – linked to high concurrency concepts.

Common load‑balancing algorithms; implement and test one.

Differences between Dubbo and Spring Cloud development.

Implement common rate‑limiting methods.

Distributed tracing implementation and understanding.

Second Round (additional)

Self‑introduction, data‑governance understanding.

How you usually improve yourself; your understanding of JUC .

Brief explanation of previous AI projects and your responsibilities.

Your current offers and interview plan.

Comprehensive view of data governance: Java development + big‑data + BI reporting + recommendation/search pipelines.

8. ByteDance

First Round

Project overview, your module, technical difficulties.

Why Kafka is fast and how rebalancing is handled.

History of HTTP, pros/cons, public/private key encryption.

Operating system memory, process, I/O, file management basics.

LeetCode 8 – implement atoi with edge‑case handling.

Second Round

Project description and job responsibilities.

Hive execution internals.

Hadoop evolution – HDFS, MapReduce, YARN components and data flow.

Kafka producer‑consumer speed imbalance and rebalancing.

Redis and MySQL common interview topics.

LeetCode 236 – Lowest Common Ancestor of a Binary Tree.

Third Round

Understanding of ZooKeeper.

Project discussion, technical shortcomings, handling duplicate consumption.

Macro‑level comparison of RabbitMQ and Kafka.

How to dynamically modify thread‑pool parameters ( link ).

Hive execution fundamentals.

String manipulation puzzles.

Transitioning from Java to Go language.

9. Kuaishou

First Round

Detect if a linked list has a cycle, find entry, compute length; why fast pointer moves two steps.

Thread interruption usage.

LeetCode 124 – Maximum Path Sum in a binary tree.

JUC high‑frequency interview topics.

Compare synchronized vs Lock and when to use each.

Bitmap usage for presence/absence statistics.

Scenario‑design questions that require you to narrow down from a broad answer.

Second Round

Data‑governance issues when rule engine changes frequently – ensure efficient external services.

Big‑data pipeline from collection to external service; handling MySQL, Redis, MongoDB data sources.

Considerations for OLAP, OLTP, high performance, high availability, scalability.

How to verify file consistency between two servers with minimal data transfer.

MySQL high‑availability and your understanding of high concurrency .

Data‑governance ideas.

Have you heard of lossless degradation?

Bloom filter concepts and multiple Bloom filters.

Service‑governance thinking.

Game‑theoretic problem: 10 candies, max 3 per turn – guarantee a win; extend to n candies.

Third Round

Describe your responsibilities, biggest challenge, and best project.

Understanding of big‑data architecture.

How to implement a fast counter similar to i++ (LongAdder, ThreadLocal).

Hive implementation details and window functions.

Common Redis interview points.

Object header and lock escalation details.

Design a scheduler to crawl 100 000 URLs with per‑node rate limits.

Kafka architecture and leader election understanding.

Daily learning methods and transitioning to a new job.

Reflections

First Round : Mostly tests basic coding ability and common interview questions; deep system‑design questions are rare.

Second Round : Usually with team lead; focuses on scenario design and your personal methodology.

Third Round : Typically with director; probes data‑structure design, scenario design, tool internals, and overall knowledge depth.

Cross‑Interview : If you have a strong academic background or long experience, a cross‑department leader may interview you.

Timeline : Companies like Alibaba and Tencent have interview cycles of 40+ days; be prepared for a long battle.

Compensation : Your performance in the three technical rounds influences level and salary expectations.

Common Topics : Build a personal knowledge system for typical interview topics; use blogs, CSDN, Juejin, or public accounts to organize them.

Scenario Design : The most enjoyable and discriminating part; after many interviews, I often forget details, so I now record them immediately.

Accumulation : The IT field evolves quickly; maintain a Keep Learning mindset.

Mind‑Map : I have a half‑finished mind‑map covering 60% of topics; readers can request the link via my public account.

End : This write‑up is a bit rambling, but I hope it helps the readers.

Recommended Reading:

If anyone asks you about MySQL index principles, share this article!

Nginx + Tomcat load‑balancing configuration

What do you call this thing? Token?

Welcome to follow the WeChat public account: Internet Full‑Stack Architecture , which provides more valuable information.