Katkat

practice a little every day, paws crossed ♡

Software Engineer Interview Questions

Practice 9403 coding, system design and machine learning questions from 546 companies, sorted by role, topic and interview round. Every question has step-by-step hints, a code runner that supports 8 languages and an AI mentor; members also get the full solution walkthrough.

9403
Questions
546
Companies
11
Topics
8
Languages

Showing 4621–4650 of 5874 results

  • RipplingHardSoftware Engineer
    Design a flexible expense reimbursement system

    This question evaluates system design and architecture skills for building a policy-driven, explainable expense reimbursement platform, specifically testing competencies in rule engines and DSL/config design, versioning and immutable evaluations, group-level aggregation and conflict resolution, data modeling and partitioning for scale, API and workflow design, observability/auditing, and access control. As a System Design interview prompt it is commonly asked because it forces candidates to articulate trade-offs between extensibility, explainability, consistency, and performance; the assessment targets practical application of architectural principles with strong conceptual reasoning.

    System DesignTechnical Screen
  • RipplingHardSoftware Engineer
    Design a hotel search and booking system

    This question tests the ability to design a distributed, high-concurrency reservation system that handles inventory management, consistency, and search efficiency.

    System DesignOnsiteDistributed SystemsConcurrencyDatabase Sharding
  • RipplingMediumSoftware Engineer
    Design a large-scale news app with caching

    This question evaluates a candidate's ability to design a scalable news application with emphasis on caching strategies and cross-device read-state synchronization, assessing skills in system architecture, API design, data modeling, distributed caching, and consistency handling.

    System DesignOnsite
  • RipplingMediumSoftware Engineer
    Design a music player with favorites cap

    This question evaluates a candidate's ability to design and implement in-memory data structures, stateful APIs, concurrency handling, deterministic policy enforcement for a fixed-capacity favorites feature, and reasoning about edge cases like removing the currently playing track or handling invalid IDs.

    Coding & AlgorithmsOnsite
  • RipplingHardSoftware Engineer
    Design a news aggregation and feed service

    This question tests the ability to design a distributed system capable of ingesting high-frequency news feeds from multiple sources and serving personalized, low-latency content to millions of users.

    System DesignOnsiteScalabilityCachingMicroservices
  • RipplingMediumSoftware Engineer
    Design a news aggregator like Google News

    This problem tests your ability to design a distributed system that fetches, normalizes, and ranks news articles from various heterogeneous sources while maintaining high availability and low latency for users.

    System DesignTechnical ScreenDistributed SystemsCachingScalability
  • RipplingMediumSoftware Engineer
    Design a personalized news aggregator

    This question evaluates a candidate's competence in large-scale system design, covering concepts such as high-throughput API ingestion, idempotent processing and deduplication, indexing and storage, caching, and low-latency personalized feed generation.

    System DesignOnsite
  • RipplingHardSoftware Engineer
    Design a real-time delivery dashboard

    This question evaluates skills in designing scalable, low-latency real-time distributed systems—covering event ingestion and streaming, geospatial indexing, state management, consistency and availability trade-offs, fault tolerance, monitoring, and cost/performance considerations—and is categorized under System Design.

    System DesignTechnical Screen
  • RipplingHardSoftware Engineer
    Design a scalable expense rules engine

    This question evaluates system-design and data-modeling competency for building a scalable, multi-tenant rules engine (category: System Design) that supports per-entity and aggregate (trip-level) evaluations, backward-compatible APIs, explainability/auditability, parsing/validation of string-typed inputs, and operational concerns like determinism, idempotency, and resilience. It is commonly asked to assess trade-off reasoning around extensibility, evaluation semantics (priority, combinators, short-circuiting), aggregation and caching strategies, and API/data-model stability, with a level of abstraction that is practical application focused while requiring conceptual architectural trade-offs and concrete design details.

    System DesignTechnical Screen
  • RipplingMediumSoftware Engineer
    Design a scalable logging system

    This question evaluates a candidate's ability to design scalable, reliable logging and observability infrastructure, testing competencies in distributed systems, ingestion pipelines, indexing and data modeling, storage and retention policies, multi-tenancy, and performance/reliability trade-offs.

    System DesignOnsite
  • RipplingMediumSoftware Engineer
    Design a user behavior monitoring system

    This question evaluates a candidate's ability to design scalable, low-latency user event ingestion and analytics pipelines while reasoning about data storage choices and aggregate correctness trade-offs.

    System DesignOnsite
  • RipplingHardSoftware Engineer
    Design a user behavior tracking system

    This question evaluates competency in designing scalable event-driven systems, covering client SDKs and server ingestion, buffering and delivery guarantees, schema evolution, storage trade-offs for interactive dashboards versus large-scale warehousing, enrichment placement, and privacy/compliance controls.

    System DesignTechnical Screen
  • RipplingMediumSoftware Engineer
    Design an Extensible Expense Rule Engine

    Design an extensible expense rule engine that reports every applicable violation for each expense. The answer separates rule implementations from the evaluation loop, defines deterministic structured results and money handling, and covers boundary tests, malformed data, rule versioning, aggregate-rule extensions, and OOP trade-offs.

    Software Engineering FundamentalsTechnical Screen
  • RipplingHardSoftware Engineer
    Design an Extensible Expense Validation Engine

    Design an object-oriented validation engine that evaluates an expense report against modular, multi-scoped policies and aggregates all policy violations.

    Software Engineering FundamentalsTechnical Screenobject-oriented-designclean-architecturehash-table
  • RipplingMediumSoftware Engineer
    Design an ad-click aggregation and enrichment pipeline

    This question evaluates system design and data engineering competencies, focusing on large-scale streaming ingestion, aggregation, enrichment joins, deduplication, and trade-offs between request batching and latency for mobile networks.

    System DesignOnsite
  • RipplingMediumSoftware Engineer
    Design an extensible expense rule evaluator

    This problem tests your ability to design a flexible and extensible rule evaluation engine capable of processing expense reports against dynamic business policies.

    Software Engineering FundamentalsTechnical ScreenSystem DesignDesign PatternsExtensibility
  • RipplingMediumSoftware Engineer
    Design an extensible poker-hand evaluator

    This question evaluates object-oriented design and software architecture skills, specifically the ability to define modular classification and comparison responsibilities for a game-hand evaluator as part of Software Engineering Fundamentals.

    Software Engineering FundamentalsTechnical Screen
  • RipplingMediumSoftware Engineer
    Design article voting and flip-tracking system

    This question tests your ability to design a stateful system for tracking user interactions (upvotes/downvotes) on content while maintaining an audit trail of user activity.

    Software Engineering FundamentalsTechnical ScreenObject-Oriented DesignData ModelingConcurrency
  • RipplingMediumSoftware Engineer
    Design centralized log ingestion and query system

    This problem tests your ability to design a distributed log processing pipeline capable of handling high-throughput ingestion and efficient time-range retrieval.

    System DesignTechnical ScreenDistributed SystemsLoggingData Pipelines
  • RipplingMediumSoftware Engineer
    Design delivery driver payment system

    A Rippling software-engineer system-design screen: build an in-memory, object-oriented driver-payroll service with add_driver, record_delivery, get_total_cost, pay_up_to, and get_total_cost_unpaid. It tests time-interval accounting, integer-cents money math, idempotent partial-vs-whole payout state, double-pay prevention for overlapping work, and a clean path from prototype to a transactional, indexed production design.

    System DesignTechnical Screen
  • RipplingMediumSoftware Engineer
    Design in-memory delivery billing core APIs

    This problem tests your ability to design an efficient in-memory service for managing delivery billing, requiring careful consideration of concurrency, precision in monetary calculations, and optimized aggregation of billable events.

    System DesignOnsiteConcurrencyData StructuresAPI Design
  • RipplingMediumSoftware Engineer
    Design personalized news aggregation service

    This question tests the ability to design a scalable news aggregation system that balances real-time content ingestion with personalized ranking for a large user base.

    System DesignTechnical ScreenScalabilityDistributed SystemsRanking
  • RipplingHardSoftware Engineer
    Design poker-like hand comparison with custom ranking

    This question evaluates object-oriented design, rule-based comparison logic, and algorithmic reasoning for ranking and tie-breaking of card hands, including skills in extensibility and comparison-key representation.

    Software Engineering FundamentalsTechnical Screen
  • RipplingHardSoftware Engineer
    Design several backend components

    This problem tests your ability to design a robust backend architecture for an employee management system, focusing on data consistency, audit logging, and extensible API design.

    Software Engineering FundamentalsHR ScreenSystem DesignDatabase ModelingConcurrency
  • RipplingHardSoftware Engineer
    Design several large-scale systems

    This question tests the ability to design a distributed, high-concurrency reservation system that requires strong consistency for inventory management and low-latency read access for search.

    System DesignHR ScreenScalabilityConcurrencyConsistency
  • RipplingHardSoftware Engineer
    Evaluate Configurable Rideshare Payout Audit Rules as Data

    Implement a generic rule-evaluation engine for a rideshare payout audit tool, where per-fare and per-driver-total rules, each with its own AND-combined conditions, are supplied entirely as data rather than hard-coded branches, using exact integer-cent arithmetic.

    Coding & AlgorithmsTechnical Screenrule-enginedesigndata-modeling
  • RipplingHardSoftware Engineer
    Evaluate Expense and Trip-Level Rules as Data

    Evaluate configurable expense and trip-sum rules using exact cents, reusable typed predicates, strict thresholds, multiple flags, and deterministic result ordering.

    Coding & AlgorithmsTechnical Screen
  • RipplingMediumSoftware Engineer
    Event-Kitchen Prep Scheduler: Dependencies, Priority, Filters

    Build a scheduler for a catering kitchen's prep tasks: a task can't start before its dependencies finish, higher-priority ready tasks jump the queue, and a dietary filter can remove tasks whose downstream dependents must then re-route around them. Tests topological ordering, deterministic tie-breaking, cycle handling, and precisely specifying filter-removal semantics.

    Software Engineering FundamentalsTechnical Screentopological-sortgraphsheap
  • RipplingMediumSoftware Engineer
    Explain JS event loop and related concepts

    This question tests your knowledge of the JavaScript runtime architecture, specifically the distinction between macrotasks and microtasks, and your ability to predict execution order in asynchronous programming.

    Software Engineering FundamentalsTechnical ScreenJavaScriptEvent LoopAsynchronous
  • RipplingHardSoftware Engineer
    Explain Your Current and Previous Engineering Roles

    Introduce current and previous engineering roles with clear team purpose, personal scope, concrete responsibilities, and relevant progression.

    Behavioral & LeadershipHR Screen