Airtable Software Engineer Interview Questions

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 exercis

## Problem Detect circular references or dependency cycles in a spreadsheet cell or graph structure. ## Likely LeetCode equivalent No direct unambiguous match. ## Tags graph, hash_table, recursion

## Problem Given a table as a list of rows (each row is a list of string values), infer the most specific data type for each column. Types in priority order: `int` > `float` > `date (YYYY-MM-DD)` > `boolean (true/false)` > `string`. A column's type is the most specific type that all non-empty values in that column can be parsed as. ```python def infer_column_types(rows: list[list[str]]) -> list[str]: pass ``` **Example:** ``` rows = [ ["1", "3.14", "2023-01-01", "true", "hello"], ["2", "2.71", "2023-06-15", "false", "world"], ["abc", "1.0", "not-a-date", "true", "!"], ] output -> ["string", "float", "string", "boolean", "string"] ``` ## Follow-ups 1. Empty cells -- should they be treated as missing (skip for type inference) or as the string `""`? 2. Dates appear in multiple formats (`MM/DD/YYYY`, `DD-MM-YYYY`). How do you handle ambiguous formats? 3. A column is 99% integers but has one outlier string. What threshold would you use to decide the type? 4. Extend to also return nullable status: a column is nullable if any cell is empty.

## Problem Design or implement a connection pool with acquire/release semantics and a maximum connection limit. ## Likely LeetCode equivalent No direct match with high confidence. ## Tags design, queue, coding_other

## Problem Find all groups of duplicate files in a filesystem by comparing file content hashes or sizes. ## Likely LeetCode equivalent LeetCode 609 - Find Duplicate File in System. ## Tags hash_table, strings, arrays

## Problem Design a file backup strategy or determine minimum files to back up given constraints. ## Likely LeetCode equivalent No direct match with high confidence. ## Tags greedy, arrays, coding_other

## Problem Build or construct a file directory structure from a list of paths or operations. ## Likely LeetCode equivalent No direct match with high confidence. ## Tags strings, hash_table, coding_other

## Problem You have a list of tasks, each with a `duration` (minutes) and a `deadline` (minute of the day they must finish by). The day starts at minute 0. You can process only one task at a time. Maximize the number of tasks completed before their deadlines. ```python def max_tasks_finished(tasks: list[dict]) -> int: # tasks: [{"name": str, "duration": int, "deadline": int}] pass ``` **Example:** ``` tasks = [ {"name":"A", "duration":60, "deadline":120}, {"name":"B", "duration":30, "deadline":50}, {"name":"C", "duration":100, "deadline":200}, ] # Greedy: B (done at 30 < 50), A (done at 90 < 120), C (done at 190 < 200) output -> 3 ``` ## Approach Sort by deadline (Earliest Deadline First). Greedily schedule tasks in deadline order, accumulating time. If adding a task would miss its deadline, skip it. EDF is optimal for maximizing task count with unit-equivalent tasks. ## Follow-ups 1. Prove that Earliest Deadline First is optimal here, or describe a case where it fails. 2. Tasks now have integer priorities. You want to maximize total priority, not count. How does your algorithm change? 3. Some tasks are dependent -- Task C cannot start until Task A finishes. How do you incorporate dependencies? 4. The schedule must also include mandatory breaks (e.g., 30-minute lunch at minute 240). How do you insert them?

## Problem Implement an in-memory database table that supports: - `insert(row: dict)` -- add a row (rows have a unique `id` field). - `delete(id)` -- remove a row by id. - `query(filters: dict) -> list[dict]` -- return all rows matching all key-value filters (AND semantics). - `update(id, changes: dict)` -- update specific fields of a row. ```python class Table: def insert(self, row: dict) -> None: ... def delete(self, id: int) -> None: ... def query(self, filters: dict) -> list[dict]: ... def update(self, id: int, changes: dict) -> None: ... ``` **Example:** ``` t.insert({"id":1,"name":"Alice","dept":"Eng"}) t.insert({"id":2,"name":"Bob", "dept":"Eng"}) t.query({"dept":"Eng"}) -> [{"id":1,...},{"id":2,...}] t.update(1, {"dept":"PM"}) t.query({"dept":"Eng"}) -> [{"id":2,...}] ``` ## Follow-ups 1. `query` scans all rows. How would you add an index on a specific column to speed up equality lookups? 2. Support range queries (`age > 30`). What data structure would you use for a range index? 3. How do you handle schema evolution -- adding a new column to existing rows? 4. Implement `query` with OR semantics as well as AND. How does the filter language change?