Pinterest Software Engineer Interview Process

Pinterest grades Software Engineers on finished, running code more than on the right idea. Coding problems are product-framed and arrive in parts: an elevator picker becomes a timed multi-elevator simulation, a violation log becomes a time-range query, a subtree deletion becomes an in-place compaction. Most rejections trace to a part left unfinished or a bug left unresolved, even after strong design and behavioral feedback. Design rounds lean on Pinterest's merchant-catalog and ads backend, and some 2026 loops added an AI-assisted coding round set in an existing codebase.

This guide breaks down each stage of the Pinterest Software Engineer interview, what interviewers evaluate in each round, and how to prepare, with questions candidates were actually asked.

Verified: Based on 47 candidate-reported interview experiences, primarily from 2024 Q3 through 2026 Q3, cross-checked against recent public accounts.

Pinterest Software Engineer interview process

Pinterest runs one general loop for Software Engineers and matches candidates to teams afterward, so problems draw on the product in general: pins, boards, ads, merchant catalogs. Experienced candidates take one or two phone screens and then a virtual onsite of four to six sessions, typically 45 minutes each.

New graduates and interns take a timed assessment, a short recruiter call, one technical interview and then three hour-long technical interviews. Mid-level loops (IC14) usually have two or three coding rounds and one or two design rounds; senior loops (IC15 and above) carry two design rounds.

Here's what the interview process can look like:

• Recruiter screen: About 30 minutes on background, target level, location under Pinterest's flexible work model, and timeline.
• Online assessment (new grads and interns): A timed set of about four algorithm problems of rising difficulty, taken before any live interview.
• Technical phone screen (one or two): 45 to 60 minutes in a shared editor: one multi-part problem or two related ones, sometimes a small class design.
• Coding interviews (two or three): 45-minute onsite rounds, each one product-framed problem with two to four follow-up parts.
• AI-assisted coding interview (some 2026 loops): Directing an AI assistant to extend an existing codebase, usually by adding caching, and testing the result.
• System design interviews (one or two): Backend designs from Pinterest's own surface: catalog ingestion, typeahead, leaderboards, ads events, notifications.
• Behavioral interview: Ownership, feedback, conflict and initiative, sometimes run by the hiring manager.
• Team matching: After the loop is approved, conversations with interested teams, which lead to the actual offer.

Tip: Treat the first part of every problem as a 15-minute warm-up. Interviewers queue two to four follow-ups; one candidate who could not code the last two parts but explained them clearly still passed, while candidates who never reached the follow-up were rejected.

Recruiter screen

The recruiter call is short and logistical: current role, target level, team interests, location and timing. It sets the level of the loop, which does not change once the onsite starts. One senior candidate's recruiter left the company mid-loop, which caused delays and miscommunication.

Interviewers evaluate:

• Level fit: Scope of your recent work against IC14 (Software Engineer II) or IC15 (Senior) expectations.
• Track fit: Backend, full-stack or infrastructure leaning, used later in team matching.
• Motivation: A concrete reason for Pinterest, ideally tied to a product surface.

Ask the recruiter which level the loop is calibrated for and how many design rounds it includes before you schedule the onsite.

Sample questions for the recruiter screen

Here are some questions reported by recent candidates:

• Tell me about your current role and the systems you own.
• Why Pinterest, and which product areas interest you?
• What level are you targeting, and what is your timeline?

Technical phone screen

The screen runs 45 to 60 minutes in a shared editor; some interviewers want your own tests run, others accept a class interface in plain text. Most screens are one problem that unfolds in parts. An elevator picker returns the nearest elevator that can serve a passenger (idle, or moving toward the passenger in the same direction), then becomes a simulation in which passengers arrive over time and you report which elevator the last one boards. A sparse matrix stored as a dictionary must be printed, added (dropping entries that cancel to zero) and multiplied. A parent-index forest has a subtree marked deleted, then compacted with parent indices remapped.

Other screens are small data-structure designs with complexity contracts. An escape-room leaderboard ranks players by room, then by arrival order, with getTop(k), proceedToNextRoom and getPeople. An access-control tree supports grant, revoke and check, where the deepest explicit rule wins. Familiar problems come back with a twist: a warehouse box-placement problem switched its objective from box count to total height, and a subarray-score count required linear time from the start.

Interviewers evaluate:

• Completing the parts: Reaching the later follow-ups, at least in pseudocode, rather than polishing part one.
• Clarifying the model: Whether arrival order resets on a room change, or what "no rule" means in a hierarchy.
• Index discipline: Two-pointer windows, index remapping and nested loops without off-by-one errors.
• Complexity reasoning: Justifying a tree set, heap or linked-list bucket against a stated bound.

Practice multi-part problems against a 45-minute clock, writing part one in under 15 minutes.

Note: Both clear phone-screen rejections came from execution, not from the idea. One candidate explained the O(n) sliding window correctly but could not get the index logic right, and another knew the sparse-matrix approach but was slow on the multiplication loop and on pruning entries that summed to zero.

Sample questions for the technical phone screen

Here are some questions reported by recent candidates:

• Return the nearest elevator that can serve a passenger, then simulate timed arrivals to find which elevator the last passenger boards.

• Model players moving through numbered rooms so that a move and a room lookup are constant time and the leaderboard is built in O(N + k).

• Mark a target node and its descendants as deleted in a parent-index array, then compact the array, preserve order and remap parents.

• Model Elevator Dispatch for Sequential and Overlapping Calls

• Escape Room

• Grant / Revoke / Check Access on Hierarchy

• Tree-Encoded Subtree Deletion and Stable Compaction

• Sparse Matrix Operation

Coding interviews

The onsite has two or three coding rounds of about 45 minutes. Problems are medium with occasional hard ones and recur across candidates in a few families: graphs of pins and boards (connectivity, distance between boards through shared pins, bus-route style transfers), itinerary reconstruction with a loop-detection twist, ledger settlement from multi-payee transactions, violation-log queries, and expression building. Product framing hides standard patterns: a masonry grid places each pin in the shortest column (a min-heap), and a screen filled exactly with the fewest pins is a coin-change DP.

Follow-ups change the problem rather than polish it. A +/* expression search evaluated left to right becomes a second function that respects precedence and returns every matching expression. A per-second count of interacted pins becomes arbitrary timestamps (sort and sweep), then duplicate pins across users (reference counts). Some interviewers stay silent and give no hints.

Interviewers evaluate:

• Bug-free completion: One candidate with strong design feedback was rejected after a nested-iterator solution failed a single test and a multithreaded delayed queue produced no code.
• Recognizing the pattern under the story: Candidates who overbuilt a board-and-pin problem later realized plain BFS was enough.
• Adapting without restarting: Extending the first solution when uniqueness, precedence or time bounds change.
• Data-structure fluency: Clean use of maps, sets, heaps and sorted structures in your language, for example Java HashMap calls without searching.

Practice graph traversal, sweep lines, backtracking and ledger problems, then rehearse each with two follow-ups that change the constraint.

Sample questions for the coding interviews

Here are some questions reported by recent candidates:

• Decide whether + or * between numbers kept in order can reach a target under left-to-right evaluation, then return every expression that reaches it under normal precedence.

• From (pin, start, end) interaction logs, count active pins per second, then for arbitrary timestamps, then counting each pin once across users.

• Turn multi-payee expense records into net balances and a list of direct payments that settles them.

• Return All Target Expressions With Addition and Multiplication Precedence

• Count Unique Active Pins Over Time

• Reconstruct Itinerary II

• Splitwise / Settle Group Balances

• Violation Log Analyzer

• Minimum Pins to Exactly Fill a Screen

AI-assisted coding interview

Some mid-2026 loops added a round of work in an existing codebase alongside an AI assistant. Reported tasks center on caching: add a cache to one interface by following the pattern already used on another, or have the assistant implement LRU and LFU caches, tests and a performance measurement. In one version the candidate gave only direction and review, with no direct typing. One recruiter called the round experimental and lighter-weighted, but it is still scored.

Interviewers evaluate:

• Codebase comprehension: Explaining every file the change touches and why, not just showing that tests pass.
• Critical review of generated code: Catching what the assistant got wrong instead of accepting its first answer.
• Test design: Cache hits, misses, eviction order and correctness after updates.
• Time management: Leaving time to walk the interviewer through the result.

Rehearse adding LRU and LFU caches to an unfamiliar service with an assistant, then explaining the diff aloud.

Tip: A working result is not enough. One candidate let the assistant write cache types that passed, could not explain the affected files when questioned, and ran out of time before the walkthrough; others did better by reading the existing cached interface first.

Sample questions for the AI-assisted coding interview

Here are some questions reported by recent candidates:

• Add caching to an uncached interface, following the existing cached interface, and prove it with tests.
• Direct an assistant to implement LRU and LFU caches in a provided codebase, then add tests and measure performance.

System design interviews

Mid-level loops include one design round and senior loops two, each about 45 to 60 minutes, sometimes diagrammed in the coding pad's drawing tool. The most frequent prompt is merchant catalog ingestion: merchants update product attributes singly or by bulk file upload, images arrive as originals and must be resized, and price and stock changes must land fast while images can lag. One version gave 50,000 merchants, one billion products, and write peaks and steady reads near 100,000 QPS; another pushed updates for about 500 million records to downstream services. Follow-ups ask for the database choice and how a single update and a bulk job resolve a conflict on the same product.

Other prompts: real-time typeahead (one billion users at ten searches a day, freshness for breaking events, hot-prefix shards), category leaderboards of post clicks, ads event aggregation, rate limiters, pin-comment notifications batched for viral pins, blob storage, a web crawler, and a chatbot that recommends pins.

Interviewers evaluate:

• Separating fast and slow paths: Price and inventory on a priority path, image processing asynchronous and retryable.
• Delivery semantics: Partitioning, progress tracking, retries, and at-least-once versus exactly-once stated explicitly.
• Mechanism depth: One candidate lost credit for a vague explanation of the ranking step inside an otherwise complete leaderboard.
• Scaling under change: Shard imbalance, a shard that suddenly goes viral, replica synchronization.
• Estimation at senior levels: Machine counts and throughput math, which a rate-limiter round asked for directly.

Practice catalog ingestion, typeahead and leaderboard designs until the baseline takes 20 minutes.

Note: The catalog prompt mirrors real work: Pinterest's shopping infrastructure has been scaling its product index toward a billion items. Treat bulk and single updates as two pipelines that converge on one store, and decide early how conflicts between them resolve.

Sample questions for the system design interviews

Here are some questions reported by recent candidates:

• Let merchants update price, stock, description and images singly or by bulk file, with server-side resizing and fast price changes.

• Return the top ten completions for a prefix with real-time freshness, then shard it when one prefix range runs hot.

• Rank post clicks within categories, then change the design for real-time updates and compare the trade-offs.

• Design a Merchant Catalog Update Pipeline with Bulk Files and Image Resizing

• Design Typehead Suggestion

• Leaderboard / Category Ranking

• Design Ad Click Event Aggregation System

• Keep Merchant Addresses, Social Followers, and Wiki Facts Up to Date

Behavioral interview

Every loop has at least one behavioral round, from a brisk 25 minutes to an hour with the hiring manager; one senior loop had two. Questions cover the project you owned most and how you measured it, a quick decision, feedback received and given, conflict, mentoring, and a teammate who kept missing deadlines. The tone is friendly; the scoring is not.

Interviewers evaluate:

• Initiative beyond scope: What you did that was not assigned, and how you gathered requirements from stakeholders yourself.
• Response to critical feedback: The specific change you made afterward.
• Handling an unreliable collaborator: Protecting delivery without damaging the relationship.
• Measured outcomes: How success was defined and what the numbers were.

Prepare six to eight stories with metrics, including one on negative feedback and one on a project you drove end to end.

Note: Behavioral weakness can sink a loop on its own: one rejection letter named initiative and response to negative feedback as the shortfalls. Strong behavioral feedback, however, did not rescue a candidate whose coding rounds fell short.

Sample questions for the behavioral interview

Here are some questions reported by recent candidates:

• Pick the project where you took the most ownership and explain how you measured its success.

• Tell me about a quick decision you made and the consequences you lived with.

• Describe a colleague who consistently missed deadlines and how you handled it.

• Behavioral Deep Dive: Owned Project Metrics, Fast Decisions, Feedback, and Conflict

• Leadership, Initiative, Project End-to-End

Team matching

Passing the loop moves you into team matching, not straight to an offer. Recruiters bring teams with open headcount that are interested in your packet, and each manager holds a fit conversation. How long this lasts depends on headcount and can stretch to months.

Interviewers evaluate:

• Domain alignment: Experience relevant to the team's surface, such as ads, shopping, search or infrastructure.
• Interest and questions: Specific questions about the team's roadmap and systems.
• Level fit: Whether the team's scope matches the level the loop approved.

Prepare a pitch for two or three Pinterest areas and questions that show you know what each owns.

How Pinterest levels and evaluates Software Engineer candidates

Interviewers submit independent feedback, and the packet is reviewed after the onsite before the candidate enters team matching; a matched team then extends the offer. Reported rejections usually trace to one round: an unfinished coding follow-up, a vague design mechanism, or thin behavioral stories. Rejections have come one to three days after the onsite, approvals within about a week, and one candidate inferred rejection after weeks of silence.

The target level is set before the onsite, and down-leveling happens at the IC14/IC15 boundary: two senior-track candidates finished with IC14 outcomes, one learning of it only with the offer. A senior offer elsewhere did not carry another candidate through an IC14 loop.

Tip: If the recruiter goes quiet, follow up a week after the expected response window and ask for a second point of contact.

How to prepare for the Pinterest Software Engineer interview

1. Drill multi-part problems on a clock: Solve part one in under 15 minutes and leave half the round for follow-ups that change the objective or the constraints.
2. Learn the recurring families: Elevator dispatch, escape-room leaderboards, access-control trees, forest deletion, ledger settlement, violation logs and expression building each recur.
3. Practice data-structure designs with complexity contracts: Build classes where moves are O(1) and reports are O(N + k), and justify every map, heap or linked list against the bound.
4. Finish with running code: Write your own tests, including empty inputs and values that cancel out, because one failing case has decided rounds.
5. Prepare catalog ingestion and typeahead in depth: Know fast versus slow paths, bulk versus single conflicts, freshness and hot-shard handling.
6. Rehearse AI-assisted work in an unfamiliar codebase: Add caches with an assistant, test hits and misses, and explain every changed file.
7. Bring stories on initiative and critical feedback: Those themes appear in rejection feedback, and each needs a specific action and a measured result.
8. Confirm the level before the onsite: Ask what IC14 versus IC15 requires and how many design rounds the loop includes.

About the Pinterest Software Engineer role

Pinterest Software Engineers build the backend, full-stack and infrastructure systems behind the home feed, search, shopping and ads, at a scale of several hundred million monthly users, often alongside machine-learning, product and design partners. Under the flexible work model, roles without a regular office requirement can be based anywhere in the country of employment, with periodic in-person gatherings.

Pinterest hires Software Engineers across most of its product and platform organizations. Teams include:

• Home feed and discovery: Recommendation surfaces and the developer tooling behind them.
• Search: Query understanding, typeahead, indexing and retrieval.
• Ads and monetization: Ad delivery, event tracking, reporting and ads infrastructure.
• Shopping and catalog infrastructure: Product catalog ingestion, indexing and serving for shopping and ads.
• Trust and safety: Real-time rule and action engines against abuse and policy violations.
• Core infrastructure and client platforms: Storage, reliability, and the web and mobile foundations.

Software Engineer experience and education requirements

Software Engineer II postings typically ask for a bachelor's degree in computer science or a related field, or equivalent experience, and two to three-plus years of engineering experience, often in backend services, large-scale MySQL systems or full-stack product work. Python appears frequently, and recent postings also mention using AI tools to speed up development. New-grad roles accept degrees in progress. Candidates have interviewed in Python and Java, and any mainstream language is accepted.

FAQs about the Pinterest Software Engineer interview

How long does the Pinterest Software Engineer interview process take?

The interviews usually take three to five weeks from recruiter call to onsite decision, with phone-screen feedback sometimes the same day and onsite results within about a week. Team matching comes after and can add weeks or months depending on headcount.

What is the hardest round of the Pinterest Software Engineer interview?

For most candidates, the onsite coding rounds: they are the most numerous and the most follow-up heavy, and they account for most reported rejections. At senior levels the design rounds weigh as heavily, especially on mechanism depth.

Is there an online assessment?

New graduates and interns take a timed assessment of about four algorithm problems before live interviews. Experienced candidates usually go straight to a phone screen.

How much does a Pinterest Software Engineer make?

Approximate total annual compensation in the United States:

• IC13 (Software Engineer I): ~$210K
• IC14 (Software Engineer II): ~$300K
• IC15 (Senior Software Engineer): ~$420K
• IC16 (Staff Software Engineer): ~$650K

Packages combine base salary, restricted stock units vesting over four years, and a bonus, with stock making up most of the total at senior levels.

---

Other Tracks at Pinterest

• Pinterest Machine Learning Engineer Interview Process