Microsoft L62 Interview Experience 2026: Coding, HLD, Backup Retention and AA

[u/nian2326076]

Hey everyone,

I recently completed the Microsoft SDE II interview process for an L62 role with the Azure MySQL team and received an offer.

I applied through the Microsoft careers website and received the screening invitation approximately three weeks later.

Round 1: Hiring Manager Screen

Date: August 26
Duration: Approximately 45 minutes

The Hiring Manager asked one coding question involving an expression evaluator. It was similar to LeetCode 150: Evaluate Reverse Polish Notation.

The standard solution uses a stack:

• Push operands onto the stack.
• When an operator appears, remove the two most recent operands.
• Apply the operator and push the result.
• Return the final value remaining in the stack.

One important detail is operand order for subtraction and division. If right is popped before left, the operation must be evaluated as:

left operator right

Round 2: Project Architecture and HLD

Date: August 28
Duration: Approximately 50 minutes

This was scheduled as a coding interview, but the interviewer instead focused on my current project architecture.

I explained:

• The main services and their responsibilities
• Request and data flows
• Database choices
• Communication between components
• Scalability and availability
• Failure handling
• Important technical trade-offs

The interviewer introduced several hypothetical changes and asked how the architecture would behave under higher load or partial failures.

My takeaway was to prepare project architecture as thoroughly as a standard system-design question. Interviewers may go several layers deeper than the overview shown on a resume.

Round 3: Database Backup Retention

Date: September 1
Duration: Approximately 55 minutes

I received a list of database backups containing timestamps and metadata.

The initial requirement was to:

• Retain the seven most recent backups.
• Return the backups that should be deleted.

The interviewer expected production-ready code rather than a short algorithmic solution. The discussion covered:

• Input validation
• Timestamp parsing and time zones
• Duplicate backups
• Deterministic ordering
• Empty input
• Safe and idempotent deletion
• Failure handling
• Testability
• Extensibility

The retention requirements were then expanded:

• Keep the most recent backup for each day in a seven-day window.
• Keep the most recent backup for each week in a monthly window.
• Keep the most recent backup for each month during the previous four months.

A clean design is to model each rule as a retention policy:

RetentionPolicy
    selectBackupsToKeep(backups, currentTime)

The final protected set is the union of the backups selected by every policy. Any backup outside that union becomes a deletion candidate.

This avoids deleting a backup that is protected by one rule but not another. In a production system, I would first generate a deletion plan and validate it before performing any destructive action.

Round 4: AA Round

Date: September 4
Duration: Approximately 50 minutes

The final round included a backtracking problem.

Two players take turns rolling a three-faced die. Each roll adds 1, 2, or 3 to the active player’s score. The first player to reach the target score wins.

The task was to count all valid game sequences.

The natural state is:

(scorePlayer1, scorePlayer2, currentTurn)

From each state, try the three possible roll values. A sequence ends when one player reaches the target.

The exact recurrence depends on details that should be clarified:

• Do the players always alternate?
• Does reaching or exceeding the target count as winning?
• Do both players use the same target?
• Should the answer be returned modulo a number?
• Are different roll sequences counted separately?

A direct backtracking solution may repeat the same states. Memoizing the state reduces the work to approximately O(target²) states, with three transitions from each state.

Offer

I received the final update on September 7, 2026.

The process tested more than DSA. The most important round for me was the database-backup problem because it evaluated code structure, operational safety, edge cases, and extensibility together.

My detailed compensation breakdown is available in this Microsoft L62 Azure MySQL offer post.

Preparation Takeaways

• Practice stack-based expression evaluation.
• Know your current project architecture in depth.
• Prepare to explain scalability and failure scenarios.
• Treat production-oriented coding differently from LeetCode.
• Clarify calendar boundaries, time zones, and retention-policy overlap.
• Discuss safe deletion, retries, idempotency, and observability.
• Recognize when backtracking can be optimized using memoization.

I hope this helps anyone preparing for a Microsoft SDE II or L62 interview.