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 2161–2190 of 2810 results

  • 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 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 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
    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
    Extend an Expense Rules Engine with Nested Boolean Conditions

    Extend an expense rules engine with validated AND/OR/NOT expression trees, typed leaf operators, explicit missing-field semantics, and explainable evaluation.

    Software Engineering FundamentalsTechnical Screen
  • RipplingMediumSoftware Engineer
    Extend rules for trip-level aggregates and outputs

    This interview question evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer for Extend rules for trip-level aggregates and outputs states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    System DesignTechnical Screen
  • RipplingEasySoftware Engineer
    Extensible Logger With Independent Handlers and Any-Keyword Search Over Stored Logs

    An object-oriented design and coding question about a logger with independent handlers that strip a configured string, truncate, uppercase or store messages, followed by a case-sensitive any-keyword search over stored logs. It tests extensible design patterns, indexing for fast search, and scaling a logger to production volume.

    Software Engineering FundamentalsTechnical Screen
  • RipplingMediumSoftware Engineer
    Find median of two sorted arrays

    This question evaluates algorithmic problem-solving skills related to sorted arrays and median computation, testing competency in handling numeric order properties and complexity analysis within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • RipplingMediumSoftware Engineer
    Find minimum of unknown convex function

    This question evaluates a candidate's understanding of convex optimization and zeroth-order (query-based) algorithm design, including reasoning about sample complexity, interval-reduction strategies, and robustness to noisy function evaluations.

    Machine LearningTechnical Screen
  • RipplingMediumSoftware Engineer
    Find the Best and Worst Completion of a Partial Numeric Hand

    Find the strongest and weakest five-card completions of a partial numeric hand under custom category and right-to-left tie-break rules while sharing one extensible comparison engine.

    Coding & AlgorithmsTechnical Screen
  • RipplingEasySoftware Engineer
    How would you scale rule evaluation?

    This question tests your ability to design a high-throughput, rule-based processing engine that balances performance, scalability, and maintainability under high load.

    System DesignTechnical ScreenRule EngineScalabilityCaching
  • RipplingMediumSoftware Engineer
    Implement A Prioritized Task Scheduler With Parent Dependencies

    Implement a task scheduler that manages parent-child task dependencies, applies custom multi-field tie-breaking priority rules, supports filtering, and handles dependency cycles.

    Software Engineering FundamentalsTechnical ScreenHeap / Priority QueueGraph / DAGTopological Sort
  • RipplingMediumSoftware Engineer
    Implement Article Vote Tracking

    Design an in-memory article vote tracking system that manages user upvotes/downvotes, detects vote flips to maintain an LRU-style flip history per user, and provides top-k article rankings by net score.

    Coding & AlgorithmsTechnical Screenhash-tableheapordered-map
  • RipplingMediumSoftware Engineer
    Implement Courier Delivery Cost Tracking

    Design an in-memory billing system that tracks courier pay rates over time and calculates prorated delivery costs across half-open time intervals.

    Coding & AlgorithmsTechnical ScreenDesignBinary SearchIntervals
  • RipplingEasySoftware Engineer
    Implement an article voting tracker

    This question evaluates a candidate's ability to design efficient stateful data structures and algorithms for tracking user votes, including correct handling of idempotent repeated votes, vote changes, deduplication, and retrieval of the most recent events.

    Coding & AlgorithmsTechnical Screen
  • RipplingMediumSoftware Engineer
    Plan CI Build Job Order with Prerequisites, Urgency and Filters

    Order CI build jobs so that prerequisites come first, more urgent jobs go earlier, filtered-out jobs are skipped without breaking ordering through them, and jobs can be grouped into parallel waves. Tests Kahn's algorithm, deterministic tie-breaking, cycle reporting, and turning a detailed spec into code.

    Software Engineering FundamentalsTechnical Screentopological-sortheapgraphs
  • RipplingHardSoftware Engineer
    Propagate Task Filtering Through Ancestors

    Design an algorithm to filter a hierarchy of tasks where any task failing a predicate—or having any ancestor that fails or is missing—is excluded along with all its descendants, running in linear time and preserving original order.

    Software Engineering FundamentalsTechnical Screenrecursiongraphmemoization
  • RipplingMediumSoftware Engineer
    Rank five-card hands by type, then find best and worst completions of unknown cards

    A two-part coding question on a poker-like card game: compare two five-card hands by a fixed type priority with ties broken card by card, then find the best and worst complete hands when the last cards are unknown. Tests hand classification, ordering keys, testing discipline and search over completions.

    Software Engineering FundamentalsTechnical Screen
  • RipplingMediumSoftware Engineer
    Stagehand Wage Ledger With Accrued and Settled Pay

    Design an in-memory class that tracks hourly pay for theater stagehands across logged call times, keeps running cost totals, and settles wages up to a cutoff without ever paying the same minute twice.

    Software Engineering FundamentalsTechnical Screenoop-designpayrollidempotency
  • RipplingHardSoftware Engineer
    Studio Session Billing with Rate Schedules and Exact Rounding

    Build a command-driven billing ledger where technicians' hourly rates change over time, bookings are deduplicated, and fractional cents are kept exactly until an invoice is printed with a configurable rounding mode. Tests rate lookup by time, idempotency rules, and integer-exact money handling.

    Coding & AlgorithmsTechnical Screenhash-mapbinary-searchmoney-arithmetic
  • RipplingMediumSoftware Engineer
    Task Scheduler with Dependencies, Priorities and Filters

    Coding question that asks for a task scheduler built from a detailed specification: tasks must come after their dependencies, follow priority or importance rules, and pass configurable filters. It tests topological ordering, deterministic tie-breaking, cycle handling and turning many interacting requirements into correct, tested code.

    Software Engineering FundamentalsTechnical Screen