Plaid Software Engineer Interview Experience — Coding Round with a 3-Milestone Pipeline Problem

There were two rounds total: the first was coding, and the second was a project deep-dive where I had to put together my own PPT slides presenting a project.

Plaid coding interview experience. The question was about an automation pipeline, with 3 milestones that added conditions progressively.

Milestone 1: single worker — calculate how many jobs get completed within the time limit.

The pipeline is made up of multiple stages, and stages run in order. Each stage is formatted as:

[number_of_jobs, job_time]

For example:

pipeline = [[4, 3], [10, 1]]
time_limit = 14

The first stage has 4 jobs at 3 minutes each, so 12 minutes total; the remaining 2 minutes can complete 2 jobs from the second stage, so it returns 6.

Interface:

def calculate_jobs_completed(pipeline, time_limit):
    ...

Note: only fully completed jobs count — a job that's started but not finished doesn't count.

Milestone 2: add multiple workers per stage.

Each stage's format becomes:

[number_of_jobs, job_time, number_of_workers]

Workers within the same stage can process jobs in parallel, but:

• a job can only be completed by one worker — it can't be split
• a worker can only work on one job at a time
• stages are still sequential
• only fully completed jobs count

For example:

pipeline = [[4, 3, 2], [10, 1, 1]]
time_limit = 14

The first stage has 2 workers and 4 jobs at 3 minutes each, so it finishes in 6 minutes. The remaining 8 minutes go to the second stage, which has 1 worker and can complete 8 jobs, for a total return of 12.

Interface:

def calculate_jobs_with_workers(pipeline, time_limit):
    ...

Milestone 3: within the same stage, each job has a different duration.

The input becomes:

job_durations: list[int]
num_workers: int

Jobs must be assigned in the order they appear in the array:

• initially, jobs are handed to idle workers
• as soon as a worker finishes, it immediately picks up the next unassigned job
• a job can't be split across multiple workers

Return the total time for the entire stage to finish, i.e., the makespan. Return 0 if there are no jobs.

Interface:

def calculate_stage_duration(job_durations, num_workers):
    ...

Example:

job_durations = [5, 2, 10, 4, 8]
num_workers = 2

Execution:

T=0: worker1 takes the job of duration 5, worker2 takes the job of duration 2
T=2: worker2 takes the job of duration 10
T=5: worker1 takes the job of duration 4
T=9: worker1 takes the job of duration 8
T=12: worker2 is idle
T=17: worker1 finishes

Returns 17.

The natural approach for this one is a min-heap tracking each worker's current finish time, always pulling the earliest-free worker to assign the next job.

Project deep-dive: I used Plaid's own PPT template to put together a project-intro slide deck.