Microsoft Interview Questions (20+ Questions)

Discover how to use Linux Bash commands to monitor server stability by extracting uptime and the 15-minute load average. This practical guide shows how to capture these vital metrics into separate files for ongoing performance evaluation and troubleshooting in production environments.

Learn how to automate daily configuration backups with retention policies using Linux Bash scripting and cron. This guide covers building parameterized backup scripts, creating timestamped compressed archives, implementing automatic cleanup, and scheduling unattended execution, essential for disaster recovery, configuration management, and protecting against data loss in production environments.

Eliminate zombie process accumulation by implementing proper init systems (tini, dumb-init) as container PID 1. Handle SIGCHLD signals correctly, reap terminated child processes, and prevent process table exhaustion. Modify Dockerfiles to use init wrappers, verify zero zombies with /proc inspection, and ensure clean process lifecycle management. Essential for long-running containers, multi-process applications, and preventing resource leaks that degrade container stability.

Hands-on CI/CD task to update a GitHub Actions pipeline so Docker images are built and deployed per commit, ensuring traceable and reliable deployments using a local runner.

Automate Docker image tagging with Git commit SHA: build CI/CD pipelines, implement version tracking, and ensure reproducible container builds.

def find_kth_largest(nums: list[int], k: int) -> int:
min_heap = []

for num in nums:
    heapq.heappush(min_heap, num)
    
    if len(min_heap) > k:
        heapq.heappop(min_heap)
        
return min_heap[0]

def ladder_length(begin_word: str, end_word: str, word_list: list[str]) -> int:
if end_word not in word_list:
return 0

word_list.append(begin_word)
adj = defaultdict(list)

for word in word_list:
    for j in range(len(word)):
        pattern = word[:j] + "*" + word[j+1:]
        adj[pattern].append(word)
        
q = deque([begin_word])
visited = set([begin_word])
res = 1

while q:
    for _ in range(len(q)):
        curr_word = q.popleft()
        
        if curr_word == end_word:
            return res
            
        for j in range(len(curr_word)):
            pattern = curr_word[:j] + "*" + curr_word[j+1:]
            for neighbor in adj[pattern]:
                if neighbor not in visited:
                    visited.add(neighbor)
                    q.append(neighbor)
                    
    res += 1
    
return 0

Inspect a server certificate to identify missing Subject Alternative Name (SAN) entries and reissue it with the correct DNS names.

How to Determine Monthly and Quarterly Sales Trends from the monthly_metrics Table

In an SQL-based data analytics interview, you might be asked to analyze sales data trends. One such challenge could be to determine both monthly and quarterly sales trends from a given table. Let's break down t...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Practice a hard Snowflake SQL interview question tagged Microsoft that tests the LAG window function and string concatenation. In a retail transactions scenario, you must find each customer's previous product purchase using LAG partitioned by customer and ordered by date, then build a concatenated column that substitutes 'None' for NULL values. This question covers window functions and COALESCE, which are frequently tested in SQL interviews at top tech companies.

WITH joined AS (
SELECT a., r.climate
FROM {{ ref("animals") }} AS a
INNER JOIN {{ ref("regions") }} AS r
ON a.region = r.region
)
SELECT
species,
climate,
ROUND(AVG(age), 2) AS avg_age,
FLOOR(AVG(weight)) AS avg_weight,
COUNT() AS total_animals
FROM joined
GROUP BY species, climate

Master daily sales aggregation in PySpark. Learn how to join transaction tables with product catalogs and use multi-column GroupBy operations to calculate total quantities sold per category per day.

from collections import defaultdict
import bisect

class LogAggregator:
def init(self):
self.logs = defaultdict(list)

def record(self, timestamp, key):
    self.logs[key].append(timestamp)

def count(self, key, start, end):
    if key not in self.logs:
        return 0
    timestamps = self.logs[key]
    left = bisect.bisect_left(timestamps, start)
    right = bisect.bisect_right(timestamps, end)
    return right - left

Understanding and Calculating the Cart Abandonment Rate in SQL

When managing an e-commerce platform, monitoring user behavior is crucial to optimize sales and customer satisfaction. One significant metric to track is the cart abandonment rate. This metric highlights the percentage of shopping c...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

SELECT
employee_name,
department_name,
salary
FROM
(
SELECT
e.employee_name,
d.department_name,
e.salary,
ROW_NUMBER() OVER (
PARTITION BY
d.department_name
ORDER BY
e.salary DESC,
e.employee_name ASC
) AS salary_rank
FROM
employee e
INNER JOIN department d ON e.department_id = d.department_id
) AS ranked_employees
WHERE
salary_rank <= 3
ORDER BY
department_name ASC,
salary DESC,
employee_name ASC;

def plus_one(digits: list[int]) -> list[int]:
n = len(digits)

for i in range(n - 1, -1, -1):
    if digits[i] < 9:
        digits[i] += 1
        return digits
    digits[i] = 0
    
return [1] + digits

def subsets_with_dup(nums: list[int]) -> list[list[int]]:
nums.sort()
res = []

def dfs(i, current_subset):
    if i == len(nums):
        res.append(current_subset.copy())
        return
        
    current_subset.append(nums[i])
    dfs(i + 1, current_subset)
    
    current_subset.pop()
    while i + 1 < len(nums) and nums[i] == nums[i + 1]:
        i += 1
        
    dfs(i + 1, current_subset)
    
dfs(0, [])
return res

Analyzing Order Statistics in SQL: A Step-by-Step Guide to Writing the Perfect Query

Objective

In this task, you need to write an SQL query to effectively analyze the order statistics from a given table of orders. The table contains crucial information about each order, including its stat...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Master basic element interaction testing with Selenium. Learn button clicks, element verification, and dynamic content validation....

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →