Vercel Interview Questions (9+ Questions)

Restore accidentally deleted branches by leveraging Git's reflog history to find lost commits. Identify the branch's last commit hash, recreate the branch at that point, and verify all work is restored. Essential for preventing permanent data loss, recovering from mistakes, maintaining team productivity, and understanding Git's safety mechanisms for protecting committed work.

Read a mixed-format text file where each row has a different delimiter based on its type indicator, parse and separate the data into multiple CSV files using Python.

We have a product_tags table with two columns, id and tags. The tags column stores multiple tags in one single string separated by commas. Our job is to split those tags apart and count how many times each tag appears across all products. One important thing to keep in mind is that tags are case sensitive. A CTE is a temporary result set in SQL that you can reference within a single query. Our temporary table will be called split_data, and then we select id and tag from our product_tags table. First, we are using string_to_array. You basically pass a string and the separator to the function. After turning tags column into array, we will use unnest function, which will basically put each piece of our array into one separate row. We will use the count with a star function that will basically go through each row and return the amount. Using group by clause, we will group all rows with the same tag together.

We need to combine data from multiple sources into a unified report using Pandas. We are given one customers CSV file and one orders SQLite database. SQLite is a lightweight database that stores everything in a single file. We get the data from API, CSV file, and the database. We send an HTTP GET request to a URL, and the API responds with data in JSON format. Our job is to fetch data from all three sources, combine them into one unified DataFrame, and save the final report as a CSV file. We import three libraries: Requests, Pandas, and SQLite 3 to connect the database. We open the database file using connect function. Read SQL query will execute our SQL request and load the result directly into the DataFrame. Merge in Pandas connects two DataFrames based on a common column or index. It works the same way as JOIN in SQL. On indicates which common column was used to connect the DataFrames. The method is left join, which means that we keep all orders even if customer ID doesn't match. We can calculate the total amount when multiplying quantity by price. The final unified report is saved as CSV file.

WITH deduped_activities AS (
SELECT
user_id,
activity_date,
activity_type
FROM {{ ref("activities") }}
QUALIFY ROW_NUMBER() OVER (
PARTITION BY user_id, activity_date, activity_type
ORDER BY activity_date
) = 1
),
combined AS (
SELECT
a.user_id,
a.account_created_date,
a.location,
act.activity_date,
act.activity_type,
e.exit_date,
e.exit_reason
FROM {{ ref("accounts") }} a
LEFT JOIN deduped_activities act
ON a.user_id = act.user_id
LEFT JOIN {{ ref("exit_surveys") }} e
ON a.user_id = e.user_id
)
SELECT *
FROM combined
ORDER BY user_id ASC, activity_date DESC

WITH clean_clients AS (
SELECT client_id, client_name, industry
FROM {{ ref("clients") }}
WHERE client_id > 0
QUALIFY ROW_NUMBER() OVER (PARTITION BY client_id ORDER BY client_id) = 1
),
clean_transactions AS (
SELECT transaction_id, client_id, date, amount
FROM {{ ref("transactions") }}
WHERE transaction_id > 0
QUALIFY COUNT(*) OVER (PARTITION BY transaction_id) = 1
),
joined AS (
SELECT
t.transaction_id,
t.client_id,
t.date,
CAST(t.amount AS INTEGER) AS amount,
c.client_name,
c.industry
FROM clean_transactions t
INNER JOIN clean_clients c
ON t.client_id = c.client_id
)
SELECT * FROM joined

Determining the Completion Percentage of Required Training Courses for Employees

Creating an SQL query to determine the completion percentage of required training courses for employees is a common interview question that tests your ability to handle aggregate functions and conditional logic in ...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

def largest_rectangle_area(heights: list[int]) -> int:
max_area = 0
stack = []

for i, h in enumerate(heights):
    start = i
    while stack and stack[-1][1] > h:
        index, height = stack.pop()
        max_area = max(max_area, height * (i - index))
        start = index
    stack.append((start, h))
    
for i, h in stack:
    max_area = max(max_area, h * (len(heights) - i))
    
return max_area

def numIslands(grid: list[list[str]]) -> int:
if not grid:
return 0

ROWS, COLS = len(grid), len(grid[0])
islands = 0

def bfs(r, c):
    q = deque()
    q.append((r, c))
    grid[r][c] = "0"
    
    while q:
        row, col = q.popleft()
        directions = [[1, 0], [-1, 0], [0, 1], [0, -1]]
        
        for dr, dc in directions:
            nr, nc = row + dr, col + dc
            if (0 <= nr < ROWS and 0 <= nc < COLS and grid[nr][nc] == "1"):
                q.append((nr, nc))
                grid[nr][nc] = "0"
                
for r in range(ROWS):
    for c in range(COLS):
        if grid[r][c] == "1":
            islands += 1
            bfs(r, c)
            
return islands