eBay Coding Interview Questions: Auctions, Search, and Trust

eBay has run an online marketplace since 1995, and its engineering problems still carry the shape of what it is: a place where sellers - from individuals clearing out a cupboard to large businesses - list almost anything, and buyers either bid or buy outright. Three things make it distinctive in an interview. Listings come in more than one format, including auctions that close at a set time. The catalog is enormously varied, mixing new goods with used, refurbished, and collectible items that sellers describe in their own words. And because buyers and sellers are usually strangers, trust and safety is part of the core product rather than an afterthought.

This guide walks through the loop candidates commonly describe, the domain themes that tend to surface in coding and design rounds, the types of problems worth practicing, and a two-week plan. We describe representative problem categories, not invented "leaked" questions: question pools rotate, and fluency with the underlying patterns is what carries into the room.

The eBay engineering loop

Candidates typically describe a process shaped roughly like the table below. The number of rounds, their order, and the tools involved vary by team, level, location, and hiring cycle - and processes change - so confirm your specific schedule with your recruiter.

eBay's engineering spans many product areas - search, listings and selling tools, payments, trust and safety, advertising, and shared infrastructure among them - and the company hires engineers in more than one country. Ask which area your role supports and whether design is part of your loop at your level; those two answers tell you where to spend your preparation time.

Auctions and fixed-price listings

eBay supports two main ways to sell. In an auction-style listing, buyers bid until a set end time and the highest bidder wins. In a fixed-price listing, buyers purchase immediately at the listed price - eBay's Buy It Now - and sellers can also choose to accept offers. Behind the auction format sits a feature eBay describes publicly as automatic bidding: a buyer enters the most they are willing to pay, and eBay bids on their behalf in increments, enough to keep them in the lead but never beyond their limit. Increments are smaller at low prices and larger at high ones.

You will not necessarily be asked about auctions, but the format is a rich source of the reasoning interviewers like to probe:

• State machines. A listing moves from draft to active to sold, unsold, or ended early. Good code refuses transitions that make no sense, such as a bid on a listing that has already closed.
• Time as an input. An auction closes at its end time however heavy the traffic is, so closing has to be scheduled reliably - and you need to decide which clock is authoritative.
• Concurrency. Bidding can concentrate in the final moments before a listing closes. Bids on one listing must be applied in a single, well-defined order, which usually means serializing writes per listing.
• Tie-breaking. When two bidders set the same maximum, a clear rule has to be applied consistently. Earlier bid wins is the common choice, and the one used in the example later in this guide.

Topic emphasis for the coding rounds

Reports vary by team, but candidates commonly describe standard data structure and algorithm problems, often around medium difficulty, where careful handling of ordering and edge cases matters as much as the core idea. Prioritize roughly in this order:

• Hash maps and sets. Indexing bids by listing and bidder, grouping listings by seller, and deduplicating near-identical results.
• Heaps and ordered structures. The current highest bid, the next listings due to close, and top-k results by a score.
• Sorting with custom comparators. Ordering by total price including shipping, by time remaining, or by relevance, with deterministic tie-breaks.
• Strings and parsing. Tokenizing seller-written titles and normalizing sizes, units, and model numbers.
• Graphs and union-find. Connectivity questions, such as grouping accounts that share signals.
• Object modeling. Listings, bids, and orders expressed as clear types with explicit states.

Search and relevance across a huge, varied catalog

Search is where eBay's breadth turns into an engineering problem. The same search box has to serve a popular phone listed by many sellers in every condition, a collectible that exists once, and a replacement part that only fits certain vehicles. Themes worth being ready to discuss:

• Seller-written listings. Titles and descriptions are free text, so one product appears under different words, abbreviations, and occasional keyword stuffing. eBay also asks sellers for structured attributes it calls item specifics - make, model, size, color, and so on - which are far easier to filter and rank on when they are filled in.
• Query understanding. A query such as iphone 13 128gb unlocked is really a category, a model, a storage size, and a carrier condition. Predicting the category and extracting attributes often matters more than matching words.
• Ranking signals. eBay calls its default sort order Best Match, and its seller guidance says it weighs factors such as how closely a listing matches the search, price, listing quality and completeness, and the seller's track record. For auctions, time remaining and bidding activity are natural extra signals.
• Freshness. Listings sell, end, and change price constantly, and an auction's current price moves with every bid. Showing an item that has already sold is a visible failure, so index updates need to be fast and incremental.
• Compatibility lookups. In vehicle parts, eBay lets sellers list which vehicles a part fits and lets buyers search against a vehicle they have saved, which turns part of search into a compatibility lookup rather than a text match.

Typeahead over a catalog this broad is a design problem of its own; our search autocomplete walkthrough covers the trie and ranking fundamentals. In the interview itself, the strongest move is to ask what the buyer is trying to do before deciding what relevant means.

Trust and safety between strangers

Most eBay transactions happen between people who have never met, so a great deal of engineering goes into making that safe. You do not need insider knowledge of eBay's systems. You need to show that you notice adversaries exist and that every safeguard has a cost.

• Reputation. eBay's feedback system lets trading partners leave feedback for each other, and that history shapes who people choose to trade with. Designing a score means choosing a time window, deciding how much small or unusual transactions should count, and resisting manipulation through linked accounts.
• Shill bidding. eBay's rules prohibit bidding to artificially raise an item's price or desirability, whether by the seller or by anyone connected to them. Detection is naturally a graph problem: accounts that repeatedly bid on the same seller's listings, rarely win, and share signals with that seller form clusters worth reviewing. The union-find pattern is the coding-round version of that idea.
• Counterfeits and authentication. eBay has introduced authentication for certain high-value categories, where eligible items are inspected by experts before they reach the buyer - a good example of a system that spans software, logistics, and people.
• Prohibited items. Listings can be screened with text and image signals when they are created, with human review for uncertain cases and an appeals path for sellers who were flagged by mistake.
• Account security. Unusual logins, changed payout details, and sudden shifts in selling behavior are classic signs of account takeover.

The judgment interviewers listen for is the cost of each kind of mistake. A false negative lets a scam through; a false positive blocks an honest seller who may rely on eBay for income. Saying who pays for each error, and how a review queue or a lighter-touch step such as extra verification could reduce the damage, is a strong signal.

Payments: from PayPal to managed payments

eBay owned PayPal for more than a decade before the two became separate companies in 2015. In the years since, eBay has moved to handling payments on its own platform under what it calls managed payments: buyers pay through eBay at checkout, and eBay pays sellers out to their bank accounts after deducting its fees. The details have changed over time and differ by country, but the marketplace layer creates problems that a single store's checkout does not have:

• Multi-party flows. One order can involve the buyer's payment, eBay's fees, the seller's payout, a shipping label bought through eBay, and later a partial refund. Every step has to reconcile.
• Payout timing and holds. Funds can be held in some situations - for newer sellers, for example - so processing, held, and available funds are separate states with separate rules.
• Returns and buyer protection. eBay's Money Back Guarantee covers eligible purchases that do not arrive or do not match their description, so refunds, returns, and disputes are routine flows with their own states and deadlines.
• Cross-border trade. Buyers and sellers in different countries bring currency conversion, international shipping, and different local rules into a single order.

For the fundamentals underneath - idempotent operations, integer money, and append-only ledgers - our PayPal coding interview guide goes deeper, so they are not repeated here. The contrast with our Shopify coding interview guide is also useful: there, each merchant runs their own store and owns the relationship with their customers, while eBay mediates between two parties who are both its users. That makes buyer protection, holds, and disputes marketplace problems rather than one merchant's policy.

Representative problem types

These are the kinds of problems worth preparing: standard patterns that candidates commonly describe, set in eBay's domain. They are categories rather than reported prompts, so you practice the pattern instead of memorizing one question.

• Bidding and listing rules. Validate bids against the current price and increment, apply automatic bidding, and determine the winner and final price.
• Time-ordered events. Process a stream of bids and end times in order, or return the listings closing in the next few minutes with a heap.
• Multi-key sorting. Order results by relevance, total cost, or time remaining, with explicit tie-breaks.
• Text normalization and matching. Normalize seller titles and match listings to a canonical product despite different wording.
• Connectivity and clustering. Group accounts that share signals or repeatedly interact, using union-find or graph traversal.
• Rolling reputation. Compute a feedback score over a recent time window as new ratings arrive.
• Marketplace design (experienced roles). A fresh search index, an auction service that survives an end-of-auction rush, listing ingestion, trust and safety pipelines, or seller payouts.

Here is the flavor of the bidding type: a simplified version of automatic bidding with a flat increment. Bids arrive in order, each bidder submits a maximum, and amounts are integer cents.

def run_auction(bids, start_price, increment):
    # bids: list of (bidder, max_bid) in arrival order, integer cents
    leader, leader_max, price = None, 0, start_price

    for bidder, max_bid in bids:
        if leader is None:
            if max_bid >= start_price:          # first valid bid opens at the start price
                leader, leader_max = bidder, max_bid
            continue
        if bidder == leader:
            leader_max = max(leader_max, max_bid)  # raising your own maximum keeps the price
            continue
        if max_bid < price + increment:
            continue                            # below the minimum next bid: rejected
        if max_bid > leader_max:
            price = min(max_bid, leader_max + increment)
            leader, leader_max = bidder, max_bid
        else:                                   # the leader holds; ties go to the earlier bid
            price = min(leader_max, max_bid + increment)

    return leader, price

The strong answer states the rule before writing code: once a second bidder appears, the current price is one increment above the second-highest maximum, capped at the highest maximum. Ties go to the earlier bid, and raising your own maximum does not raise the price you pay. Each bid is O(1), so the whole run is O(n). Then it offers the follow-ups unprompted: increment tables that change with price, reserve prices, retracted bids, and - in a design discussion - how to serialize concurrent bids on one listing and close it exactly on time.

What interviewers tend to score

• Explicit rules and invariants. Stating how a listing or auction must behave before coding, then enforcing it.
• Precision with time and order. Tie-breaks, end times, and what happens when events arrive late or out of order.
• Relevance judgment. Recognizing that the right result depends on the buyer's intent, the category, and the item's condition.
• Adversarial awareness. Noticing how a feature could be abused, and what a false positive costs an honest seller.
• Ownership. Behavioral stories about a production issue you helped resolve or a trade-off you made for customers.

A word on integrity: prepare thoroughly and answer honestly. Auction and trust questions invite what-if follow-ups - a late bid, a tie, a suspicious account - and genuine understanding holds up under them in a way a memorized answer does not.

A two-week eBay prep plan

1. Days 1-3: Fundamentals - hash maps, strings, and sorting with custom comparators. Run each solution and test the edge cases.
2. Days 4-6: Heaps and ordered data framed as auction problems - highest bid, next listing to close, top-k results. Implement automatic bidding from scratch and test ties and late bids.
3. Days 7-8: Graphs and union-find for linked accounts, then a sliding-window reputation score that updates as ratings arrive.
4. Days 9-11: Design. Practice a search index that stays fresh as listings sell and prices change, an auction service built for an end-of-auction rush, and a trust and safety pipeline with human review and appeals.
5. Days 12-13: Behavioral stories about ownership, an incident you helped resolve, and a decision where you weighed the needs of buyers against those of sellers.
6. Day 14: A full rehearsal under time pressure - one coding problem, one design prompt, and two behavioral answers - in the same setup you will use on the day.

FAQ

What is the eBay coding interview process like?

Reports vary by team and level, but a typical path is a recruiter call, then either a timed online assessment or a live coding screen, then several final interviews that mix coding, behavioral questions, and - for experienced engineers - system design. The coding is mostly standard data structures and algorithms; what tends to stand out is careful handling of state, ordering, and edge cases. Processes change, so confirm your own schedule with your recruiter.

Will I be asked about auctions in an eBay coding interview?

Not necessarily, and you should not count on any specific question. Auction and fixed-price listing logic is simply a natural source of practical problems - validating bids, applying automatic bidding, choosing a winner, or closing listings on time - and a natural topic in design discussions about concurrent bids and end-of-auction traffic. Implementing a simplified automatic-bidding function is a good way to rehearse state, ordering, and tie-breaking.

What system design topics are relevant for eBay?

For mid-level and senior roles, natural themes include a search index that stays fresh as listings sell, end, and change price; an auction service that orders concurrent bids and closes listings at their end time; ingesting and normalizing listings written by many different sellers; trust and safety pipelines that combine automated signals with human review; and marketplace payment flows such as payouts, holds, and refunds. Expectations vary by team and level, so ask your recruiter what to prepare.

What should I study for an eBay software engineer interview?

Cover hash maps, sorting with custom comparators, heaps, string parsing, and graph traversal including union-find, and practice modeling objects with explicit states such as listings, bids, and orders. For design, practice search indexing, time-driven workflows, and abuse detection at a high level. Add behavioral stories about ownership, production incidents, and trade-offs you made for customers.

How is an eBay interview different from other e-commerce interviews?

The fundamentals are the same, but the domain is not. eBay is a marketplace where sellers ranging from individuals to large businesses list new, used, refurbished, and collectible goods in their own words, and where listings can be auctions or fixed-price. That makes bidding logic, search relevance across very different listings, and trust between strangers recurring themes, alongside the payment flows eBay manages between buyers and sellers.