I completed technical phone screen for Airtable and wanted to share my experience. No AI allowed unfortunately :(

Overview

• Quick intros
• Demo of a feature in an Airtable app
• The actual exercise
• Q/A

I really enjoyed the way the interviewer presented the problem b/c most of the time, the problem is presented as "here's the exercise, good luck". This interviewer went above and beyond and presented the product context before the actual exercise. That in my book tells me that the engineers value product thinking which is a high ROI skill in this era

The exercise

Within an Airtable app, you can create grid components. Grid components are like spreadsheets. You can create columns, add rows, delete column, delete row, update cells. When you update cells, you are able to do undo/redo. You can do the same for even the add/delete row and add/delete column operations. The interviewer did a quick demo via screen share!

I asked a few questions about the product context to identify what's in scope vs. out of scope

Where do you come in

You are given a Table class with some filled out functions. Here's the interface you have:

• Table is represented internally as a "2D dict". Something like `{row1: {col1: value1, col2: value2, ...}, row2: ....}
• row_ids array containing the list of row ids
• column_ids array containing list of column ids

The functions in Table class:

• add_column
• remove_column
• add_row(row_id)
• remove_row(row_id)
• set_cell(row, col, value)
• get_cell(row, col)
• get_row_ids()
• get_column_ids()
  These functions are really straightforward and already handle key errors by raising exception!

Iteration 1: Implement undo() and redo() for set_cell case

For this problem and future parts, you are not allowed to add function parameters to undo() and redo(). Think about why based on the product context

Simple test case:

table = Table()
table.add_row("test_row")
table.add_column("test_col")

# Set initial value
table.set_cell("test_row", "test_col", "initial_value")
assert table.get_cell("test_row", "test_col") == "initial_value"

table.set_cell("test_row", "test_col", "changed_value")
assert table.get_cell("test_row", "test_col") == "changed_value"

table.undo()
assert table.get_cell("test_row", "test_col") == "initial_value", "Undo should revert to previous value"

table.redo()
assert table.get_cell("test_row", "test_col") == "changed_value", "Redo should restore the undone change"

I bounced a couple of ideas with the interviewer and we aligned on using a diff history like approach to save on space complexity. The interviewer had me write a few test cases to verify correctness.

Iteration 2: Extend undo() and redo() for the other operations (eg: add_row, remove_row, add_column, remove_column)

I didn't get to this part by the time I completed iteration 1. I did talk about my high level thought process. Hopefully I did enough to move forward.

Tips

• Keep a consistent channel of communication with the interviewer
• Confirm your understanding of the requirements by paraphrasing what the interviewer said in your own words. Always stay on the same page
• Try to use as much of the existing code as possible. Keep your changes small so debugging is easier!
• The already implemented code is confirmed to work at least when the interviewer provided the code. Your focus should be on the undo() and redo() functions. You can modify the other functions though if it helps. The interviewer specifically called out that he liked how I used existing pieces as much as possible. Don't reinvent the wheel
• I was initially psyched by the difficulty for airtable's phone screen since interview question db suggested people got asked "implement connection pool with timeout" which was not at all on leetcode but marked as "hard". Didn't get asked that thank god. Something much more real and product facing