← StubHub Interview Insights

StubHub·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
May 2026Remote

Summary

StubHub interview for a software engineer role, one round that was essentially a design-and-code session disguised as a product problem. The prompt was meaty: build an event recommendation system that's flexible enough for multiple campaign types without hardcoding any logic. Felt more like a senior-level architecture conversation than a typical coding screen.

Questions Asked (3)

Q1

Design and implement an event recommendation system for a ticketing platform where different campaigns can compose behaviors like filtering by distance, price, and time without hardcoding any logic.

System DesignTechnical Trade-offsData Modeling
Author's notes

This is the whole interview basically.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then propose a composable architecture using a pipeline of independent filter components that can be dynamically configured per campaign. Discuss data modeling for events and campaigns, and explain how to evaluate and optimize the system for scale and performance.

Pro tip: Emphasize extensibility and testability: design each filter as a pure function with a clear interface, and use a configuration-driven approach so new filters can be added without modifying existing code. Also, mention the importance of caching and precomputation for low-latency recommendations.

1. Clarify Requirements and Scope

Ask questions to understand functional and non-functional requirements: what types of filters (distance, price, time), how campaigns are defined, expected scale, latency, and consistency needs.

2. Design Data Models

Define schemas for events, users, and campaigns. Events need attributes like location, price, time; campaigns need a list of filter configurations with parameters.

3. Architect Composable Filter Pipeline

Propose a pipeline where each filter is a self-contained component implementing a common interface. Campaigns specify an ordered list of filters with parameters, and the system applies them sequentially or in parallel.

4. Address Scalability and Performance

Discuss indexing, caching, and precomputation strategies. Consider using a search engine like Elasticsearch for efficient filtering, and caching results for popular campaigns.

5. Discuss Trade-offs and Extensibility

Compare approaches: dynamic composition vs. hardcoded logic, real-time vs. batch processing, and how to handle new filter types. Highlight maintainability and testability benefits.

Key Points to Mention

  • Use of a common interface (e.g., Filter interface with apply method) for all filters to enable composition.
  • Configuration-driven campaign definitions (e.g., JSON/YAML) that specify filter types and parameters.
  • Separation of concerns: filtering logic decoupled from campaign management and event data.
  • Caching and precomputation to reduce latency for frequently used campaigns.
  • Scalability considerations: sharding, indexing, and parallel filter execution.
  • Testing strategy: unit tests for individual filters and integration tests for composed pipelines.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q2

How would you ensure users always receive some event recommendation even when there's limited signal available about their preferences?

Product Sense & IdeationSystem DesignAdaptability & Ambiguity
Author's notes

Fallback logic.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the problem: define what 'limited signal' means and the goal of always providing a recommendation. Then propose a layered fallback strategy that gracefully degrades from personalized to non-personalized recommendations, ensuring coverage while maintaining relevance. Finally, discuss how to measure success and iterate, showing product sense and system design thinking.

Pro tip: Emphasize that even with limited signal, you can leverage contextual signals (time, location, device) and global popularity trends to provide a relevant recommendation, and always have a default fallback like trending events to guarantee coverage.

1. Clarify the problem and constraints

Ask questions to understand what 'limited signal' means (new user, sparse data, etc.) and what 'always' entails (latency, coverage). Define success metrics like coverage rate and user engagement.

2. Design a tiered recommendation strategy

Propose a hierarchy: personalized recommendations when signal exists, then contextual (time/location), then popularity-based, and finally a curated default list. Ensure each tier has a fallback.

3. Leverage available signals creatively

Even with limited signal, use implicit signals (e.g., page views, search queries) and aggregate trends (e.g., trending events in user's city) to make recommendations relevant.

4. Implement monitoring and feedback loops

Set up logging to track which tier served the recommendation and user interactions. Use this data to improve signal collection and adjust fallback thresholds.

5. Discuss trade-offs and scalability

Address potential trade-offs like relevance vs. coverage, and how the system scales with increasing users and events. Mention caching and precomputation for low-latency fallbacks.

Key Points to Mention

  • Fallback mechanisms: personalized -> contextual -> popularity -> default
  • Use of contextual signals (time, location, device) when user data is sparse
  • Global popularity and trending events as a reliable fallback
  • Cold-start problem and how to mitigate it
  • Metrics: coverage rate, click-through rate, user satisfaction
  • System design considerations: latency, caching, and precomputation

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q3

Walk through how a new campaign type could be built by combining existing filtering and scoring behaviors without modifying any existing code.

System DesignTechnical Trade-offsAPI & Integrations
Author's notes

Classic open/closed principle question dressed up in product clothing.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the existing architecture, especially the filtering and scoring components and their extension points. Then propose a composition-based design where a new campaign type is defined declaratively by combining existing filters and scorers, without touching their code. Finally, discuss how to integrate this new type via configuration or a registry, and address trade-offs like performance and maintainability.

Pro tip: Emphasize that you would validate the new campaign type through A/B testing or a canary release to ensure it meets business goals without disrupting existing campaigns. This shows you think beyond code to production impact.

1. Clarify Existing Architecture

Ask questions to understand how filtering and scoring are currently implemented, what interfaces they expose, and how campaign types are registered or configured.

2. Identify Extension Points

Determine where new behavior can be injected without modifying existing code, such as through composition, configuration, or plugin mechanisms.

3. Design Composition Strategy

Propose a new campaign type that combines existing filters and scorers in a declarative way, e.g., via a pipeline or rule set, ensuring no changes to existing classes.

4. Integrate and Register

Explain how the new campaign type would be registered and discovered, using existing patterns like dependency injection, factories, or a registry.

5. Discuss Trade-offs and Validation

Cover potential trade-offs (e.g., performance overhead, complexity) and how you would test and roll out the new campaign type safely.

Key Points to Mention

  • Open/Closed Principle: extending behavior without modifying existing code
  • Composition over inheritance: combining filters and scorers as building blocks
  • Declarative configuration or DSL for defining new campaign types
  • Registry or factory pattern for dynamic discovery and instantiation
  • Performance considerations: caching, lazy evaluation, or batching
  • Testing strategy: unit tests for composition, integration tests, and A/B testing

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.