Katkat

practice a little every day, paws crossed ♡

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 1501–1530 of 9403 results

  • AtlassianMediumSoftware Engineer
    Explain a Project Architecture Through a Technical Deep Dive

    Prepare an architecture deep dive with an end-to-end diagram, component ownership, interface contracts, design alternatives, and failure-recovery evidence.

    Behavioral & LeadershipOnsite
  • AtlassianEasySoftware Engineer
    Filter Invalid Data Events

    Tests your ability to implement a multi-condition event filtering and deduplication pipeline while preserving input order, along with complexity analysis for batch and stream processing.

    Coding & AlgorithmsTechnical Screenhash-tabledata-processingarrays
  • AtlassianMediumData Scientist
    Find 2023 NCAA championship winner

    This question evaluates proficiency in SQL data manipulation and relational reasoning, testing the ability to identify a championship winner from game result records across related tables in the Data Manipulation (SQL/Python) domain for data scientist roles.

    Data Manipulation (SQL/Python)Technical Screen
  • AtlassianMediumMachine Learning Engineer
    Find LCA in a tree and extend to a DAG

    This problem tests your understanding of tree traversal, graph theory, and how to generalize path-finding algorithms from trees to directed acyclic graphs (DAGs).

    Coding & AlgorithmsOnsiteGraphsLCATrees
  • AtlassianHardMachine Learning Engineer
    Find a secret word using match feedback

    Design an optimal querying strategy to identify a secret word from a candidate vocabulary using exact-match character feedback under a strict query budget.

    Coding & AlgorithmsOnsiteAlgorithmsMinimaxInformation Theory
  • AtlassianMediumSoftware Engineer
    Find nearest common manager for multiple employees

    This question evaluates proficiency in tree and graph algorithms (lowest common ancestor), input validation for hierarchical data (cycle and disconnected component detection), API design for constructing and querying trees, and algorithmic time/space complexity analysis.

    Coding & AlgorithmsTechnical Screen
  • AtlassianMediumSoftware Engineer
    Find smallest common organization for employees

    This problem tests your ability to navigate hierarchical structures and find the Lowest Common Ancestor (LCA) in a tree or a directed acyclic graph representing organizational reporting lines.

    Coding & AlgorithmsTechnical ScreenTreeLCADFS
  • AtlassianMediumFrontend Engineer
    Front-End Design of an Emoji Picker with a Search Field

    A candidate-driven front-end system design discussion about an emoji picker with a search field. It tests how a candidate scopes the component, models and loads the emoji catalog, ranks search results, keeps a grid of thousands of emoji fast, and supports keyboard and screen-reader users.

    System DesignTechnical Screen
  • AtlassianMediumSoftware Engineer
    Highlight the Shortest Unique Substring in Each Label

    Find and highlight the shortest case-insensitive unique substring in each label using bracket notation, breaking ties by earliest index and preserving original casing.

    Coding & AlgorithmsTechnical Screenstringshash-tabletrie
  • AtlassianMediumData Scientist
    Implement Real-Time Rate Limiting for Web Service Requests

    This question evaluates understanding of real-time rate limiting, time-windowed traffic control, and efficient per-client state management under algorithmic constraints.

    Coding & AlgorithmsTechnical Screen
  • AtlassianMediumSoftware Engineer
    Implement sequential and parallel URL requests

    Implement an asynchronous batch URL fetcher that executes requests with bounded concurrency, deduplicates network calls, preserves input order, and handles per-request errors gracefully.

    Coding & AlgorithmsTechnical Screenconcurrencyasync-awaitnetworking
  • AtlassianMediumSoftware Engineer
    Implement sliding-window rate limiter function

    This problem tests your ability to design a thread-safe rate limiter using a sliding window approach, focusing on time complexity optimization and memory management.

    Coding & AlgorithmsTechnical ScreenConcurrencyData StructuresSliding Window
  • AtlassianMediumData Scientist
    Implement sliding-window rate limiter with dual thresholds

    This question evaluates a candidate's skill in implementing efficient online sliding-window rate limiting, covering stream processing, time-based window management, per-key state maintenance, algorithmic complexity analysis, and formal correctness reasoning.

    Coding & AlgorithmsOnline Assessment
  • AtlassianMediumSoftware Engineer
    Merge intervals and design rating APIs

    Tests interval merging logic alongside stateful data structure design for tracking agent performance, calculating streaming averages, and ranking agents with deterministic tie-breaking.

    Coding & AlgorithmsTechnical Screenintervalsheaphash-table
  • AtlassianMediumSoftware Engineer
    Merge overlapping intervals

    This problem tests your ability to manipulate array-based data structures, specifically focusing on sorting and linear-time interval merging logic.

    Coding & AlgorithmsTechnical ScreenArraysSortingGreedy
  • AtlassianMediumData Scientist
    Minimize max L1 radius with k centers in 1D

    This question evaluates algorithmic problem-solving skills and understanding of clustering and optimization concepts, specifically the 1D k-center (minimax L1) problem, greedy feasibility tests, binary-search-on-answer techniques, numerical stability with large coordinates, and time/space complexity analysis relevant for a Data Scientist role.

    Machine LearningOnline Assessment
  • AtlassianEasySoftware Engineer
    Per-Caller Request Limiter Over Non-Decreasing Time Buckets

    A coding question about a rate limiter that receives requests as time bucket and caller pairs, in non-decreasing bucket order, and decides which to allow when each caller may make only a fixed number of requests per bucket. It tests stateful counting, per-key bookkeeping and correct handling of bucket changes.

    Coding & AlgorithmsTechnical Screen
  • AtlassianMediumSoftware Engineer
    Store a hierarchy and return all children

    This question evaluates understanding of hierarchical data modeling, REST API design, database schema choices (e.g., adjacency list vs alternatives), and systems-level concerns like scalability, pagination for large subtrees, and cycle prevention.

    System DesignOnsite
  • AtlassianMediumData Scientist
    Train and evaluate logistic model with regularization

    This question evaluates proficiency in supervised binary classification with logistic regression, implementation of L1 and L2 regularization, data preprocessing (missingness checks and standardization), hyperparameter selection via cross-validation, and model evaluation using ROC AUC and threshold-dependent metrics.

    Machine LearningTechnical Screen
  • AtlysMediumSoftware Engineer
    Design a Splitwise-Style Expense Splitter with Minimum-Transaction Debt Settlement

    Design a Splitwise-style shared-expense app, covering functional and non-functional requirements, API design and core entities, then implement settle() to produce payments that clear every balance and settle_optimally() to use the fewest transactions. Tests object-oriented design, exact money handling, and reasoning about optimality and complexity.

    Software Engineering FundamentalsTechnical Screen
  • AtlysMediumSoftware Engineer
    Design a Tour-Expense Splitter That Minimizes Payments

    Design a shared-expense tracker for a touring band: members log who paid for what and how it was split, the app maintains running balances, and two settlement modes produce the payments needed to zero every balance -- a simple pairwise payoff and an optimal one using the fewest transactions. Tests API/entity design plus a min-cash-flow-style algorithm.

    Software Engineering FundamentalsTechnical Screensystem-designgraphsgreedy
  • AttentiveMediumSoftware Engineer
    Design Broadcast Scheduling APIs

    This question evaluates a candidate’s ability to design scalable, reliable broadcast and scheduling systems, covering API design, data modeling, distributed scheduling, delivery semantics, idempotency, retries, and operational fault-tolerance.

    System DesignTechnical Screen
  • AttentiveMediumSoftware Engineer
    Design Robust Large-Input Processing

    This question evaluates debugging and root-cause analysis, memory management, streaming/chunked data processing (including correctness across chunk boundaries), and system reliability aspects such as observability, testing, and recovery for large-input backends.

    System DesignTechnical Screen
  • AttentiveMediumSoftware Engineer
    Design Storage for a Flexible Metrics Monitoring System

    This problem tests the ability to design a time-series storage system by balancing read/write throughput, data retention policies, and query performance at scale.

    System DesignTechnical ScreenTime-SeriesDatabaseData Modeling
  • AttentiveMediumSoftware Engineer
    Design a Data Puller for a Third-Party API Capped at 3 Requests per Second

    Design a service that pulls and syncs data from a third-party API that enforces a hard limit of 3 requests per second. It tests global rate limiting across distributed workers, retry and backoff behavior, incremental sync with checkpoints, and prioritizing work when demand exceeds the request budget.

    System DesignTechnical Screen
  • AttentiveHardSoftware Engineer
    Design a Kafka-Fed Event Analytics System for Long-Term Analysis

    A system design exercise to build an event analytics system that ingests very high-volume, concurrent event streams from Kafka and stores them for long-term analysis. It tests Kafka topics, partitions, consumers and consumer groups, delivery guarantees, and durable, queryable storage design.

    System DesignOnsite
  • AttentiveMediumSoftware Engineer
    Design a Product Catalog Ingested From Full Retailer Snapshots With Admin Overrides

    A system design question about a product catalog built from full retailer snapshot files, with 50,000 retailers, 11,000 read queries per second and a 400 ms latency target. It tests snapshot diffing, recovery from a mistaken upload, admin overrides that survive retailer updates, scaling ingestion, and observability.

    System DesignOnsite
  • AttentiveMediumSoftware Engineer
    Design a Real-Time Ad Serving System with Budgets and Impression Tracking

    Design a real-time ad serving system that picks an eligible ad for each ad request, returns it within a tight latency budget, and records impressions and clicks for billing. Tests candidate retrieval and ranking, campaign data freshness, budget enforcement across many servers, and a deduplicated event pipeline.

    System DesignOnsite
  • AttentiveMediumSoftware Engineer
    Design a Reliable Third-Party Data Ingestion Service

    Design an extensible, resilient data ingestion service capable of extracting data from heterogeneous third-party APIs while managing rate limits, pagination state, schema drift, and fault recovery.

    System DesignOnsiteData IngestionDistributed SystemsRate Limiting
  • AttentiveMediumSoftware Engineer
    Design a Scalable Catalog Service

    Design a high-throughput, read-heavy catalog service supporting draft/publish lifecycles, item versioning, search projections, and resilient rollback mechanisms.

    System DesignOnsiteCQRSE-CommerceCaching