2019–2025 Meta Production Engineer Intern OA / Interviews: 6 Experiences

Six candidates describe their coding rounds, Linux quizzes, and PE Basics interviews.

Coverage: Production Engineer internships in the US, UK, Ireland, and Israel. The earliest interview was in November 2019; the newest report was published in September 2025.

The short version

All six accounts included a coding task involving files, CSV data, or streaming input.

1. Practice file handling as well as algorithms. Candidates worked with CSV files, word counts, and command output.
2. Be ready to explain your choices. Interviewers asked about time complexity, memory use, and data structures.
3. The systems interviews differed. Some focused on Linux and OS concepts; two accounts also described design questions.
4. Keep the dates in mind. These are historical reports, not a confirmed 2026 interview plan.

A useful practice session: one small algorithm problem and one file-processing task in 45 minutes, then explain a Linux concept out loud.

01: Tel Aviv-Yafo — report published September 2025

This candidate applied through an employee referral. The process started with 18 operating-systems questions, followed by two online interviews.

The coding interview included the dinosaur CSV problem and a string-manipulation question. The candidate described the string question as straightforward but did not share its requirements.

The other interview covered OS concepts, signals, and how Linux works. There was also a design-pattern question involving something like Reddit. The report does not explain what needed to be designed, so there is not enough detail to reconstruct that prompt.

The candidate received no offer but described the experience positively. September 2, 2025 is the report date; the actual interview date and round durations were not given.

02: London/Dublin — November 2024 to February 2025

An undergraduate candidate applied in November and heard from a recruiter on November 27. After discussing graduation, availability, and interest in PE, they received a 20-question Linux fundamentals assessment, due within three business days.

They took it on December 2 and got positive feedback the next day.

Coding: December 12, 2024 — 45 minutes

The first question asked them to print the N most frequent words in a text file. The filename and N were command-line arguments.

Before coding, the candidate asked about missing files, error handling, and files with fewer than N distinct words. The interviewer welcomed those questions and sometimes asked how the candidate would handle the situation.

They counted word frequencies and sorted the results. They knew a heap could improve the approach but expected an optimization discussion afterward. The interviewer moved on instead, so the candidate asked to explain their time complexity before starting the next question.

The second task was to count friend requests between centaurs of different ages. The reported rules were:

• The recipient must be at least sender_age / 2 + 7.
• The recipient cannot be older than the sender.
• A sender over 100 cannot send a request to someone under 100.

The candidate used brute force, clarified the rules, and checked the code against an example. Time ran out before they discussed complexity.

They left feeling unsure, but the recruiter sent positive feedback about a day later.

PE Basics: January 10, 2025 — 45 minutes

After two reschedules, the final interview leaned toward system design and included database-schema discussion. The candidate had expected more OS questions.

They did not share the exact prompts. They described a conversational interview with follow-ups and hints. At one point, they forgot the name of the listen system call, and the interviewer supplied it.

The candidate felt better about this round than the coding interview but received a rejection on February 5. The reason was not confirmed.

03: Menlo Park/Bellevue — reports published January–February 2024

This candidate wrote two posts about the same interview experience, so they count as one account.

Their process was a quiz, a coding screen, and a Linux/OS final round. The quiz included multiple-choice and multiple-select questions. Networking appeared in the quiz, but the candidate said it did not come up in their later interviews.

Coding included Valid Parentheses and a script for monitoring streaming input.

The script read output from a command such as:

vmstat 1 | yourscript 7 5 200

It watched a selected column and printed an alert after consecutive readings above a threshold. The sample contained both numeric rows and repeated text headers.

The post leaves a few details unclear, including whether the alert starts on the fifth or sixth reading and what happens when a header appears. Those would be useful questions to ask before coding.

The final round was conceptual. The interviewer asked about:

• Virtual memory and how a process allocates memory.
• Context switches and system calls.
• Process lifecycles, including zombie and orphan processes.
• Paging, demand paging, swapping, and performance.
• The kernel, copy-on-write, and filesystem memory allocation.
• Tools including vmstat, iostat, strace, and pidstat.

The candidate also brought up deadlocks, threads, semaphores, and monitors. Those were topics they volunteered, rather than a confirmed list of interviewer questions.

They reported studying four to six hours a day for a week before the final. In their follow-up post, they said a mock interview and its feedback helped. The outcome was not disclosed.

04: London/Dublin — January–February 2022

This candidate was an undergraduate in India with no full-time work experience. They applied through a referral and heard from a recruiter about a week later.

The first stage was a 20-minute quiz covering Linux internals, operating systems, and networking. Some questions allowed multiple correct answers.

Coding — 45 minutes

The first task was to determine whether an array could be split into two contiguous parts with equal sums, using every element.

The candidate calculated the total sum, then scanned for a prefix equal to half that total.

The second task was to process two CSV files and rank bipedal dinosaurs by speed. One file contained names and leg lengths; the other contained names, stride lengths, and stances. A supplied formula was used to calculate speed.

The candidate started with the second file, storing the bipedal dinosaurs in a map. They then read the first file, matched the remaining information, calculated speeds, and used a priority queue to order the results from fastest to slowest.

They solved both and advanced within a week.

Systems — 45 minutes

The interview covered processes, threads, parent and child processes, and the fork–wait–exec cycle.

One question asked what happens inside the system after entering:

ls -l *

The interviewer also showed Linux command output and asked what each column meant. Other topics included swap, virtual memory, buffers, and cache.

The candidate said the repeated follow-ups made this round difficult. Knowing a definition was only the start of the discussion.

Their systems interview was on February 15. They received a rejection two or three days later.

05: UK — January–February 2021

This candidate described a process lasting roughly ten weeks:

1. A 20-question Linux quiz.
2. A coding interview.
3. A Linux troubleshooting interview.

Coding included the dinosaur text-parsing problem and splitting an array into two parts with equal sums.

The candidate found the troubleshooting round difficult. They said they answered most questions but struggled to explain some troubleshooting approaches smoothly.

They received a rejection more than a week later.

The report does not include the actual troubleshooting scenarios or detailed follow-ups. It gives a useful account of the process, but not enough information to reconstruct that final round.

06: Menlo Park — November 2019 interview

This candidate started with around 20–25 Linux multiple-choice questions in about 18 minutes.

Topics included ls -lSh, Linux log locations, signals, and debugging tools. They reported scoring 70% and advancing; that does not establish a general passing score.

Their next interview lasted 45 minutes on CoderPad, with code execution disabled for that session.

The first task was an equal-sum array split. They quickly wrote an O(n²) solution, but the interviewer asked for O(n). The candidate got stuck briefly and needed hints to improve it.

The second task involved CSV parsing and file I/O to find the fastest dinosaur of a given type, using a supplied speed formula.

The interviewer asked about memory efficiency and questioned the candidate's data-structure choices, including why they were using a dictionary. The candidate finished about half the code before time ran out, then explained the remaining steps.

They received a rejection about a week later. This account was published in January 2020 and describes an interview from November 2019.

Practice Suggestions

Start with file and stream processing. Write small scripts that open files, parse CSV, take command-line arguments, and read standard input. File or stream processing appeared in every account here.

Explain the code as you go. Practice prefix sums, frequency counting, sorting, heaps, and parentheses validation. Be ready to explain the time and memory costs without waiting to be asked.

Use Linux while you study it. Read actual vmstat or iostat output. Explain what the numbers mean, what you would investigate next, and why.

Leave some time for basic design. Two candidates encountered design discussions, though neither shared a complete prompt. Practice explaining how you would organize a small service or database.

Before the interview

• Can you read and join two files without loading more data than you need?
• Can your script handle command-line arguments, a missing file, and repeated input?
• Can you explain your time and memory use?
• Can you describe how a process starts, allocates memory, makes a system call, and exits?
• Can you explain what a Linux command does and answer follow-up questions without relying on memorized definitions?