Attentive interview questions

Showing 1–16 of 16 results

• Design Broadcast Scheduling APIsMedium

  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.

  AttentiveSoftware EngineerSystem DesignTechnical Screen
• Design Robust Large-Input ProcessingMedium

  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.

  AttentiveSoftware EngineerSystem DesignTechnical Screen
• Design Storage for a Flexible Metrics Monitoring SystemMedium

  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.

  AttentiveSoftware EngineerSystem DesignTechnical Screen
• Design a Data Puller for a Third-Party API Capped at 3 Requests per SecondMedium

  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.

  AttentiveSoftware EngineerSystem DesignTechnical Screen
• Design a Kafka-Fed Event Analytics System for Long-Term AnalysisHard

  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.

  AttentiveSoftware EngineerSystem DesignOnsite
• Design a Product Catalog Ingested From Full Retailer Snapshots With Admin OverridesMedium

  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.

  AttentiveSoftware EngineerSystem DesignOnsite
• Design a Real-Time Ad Serving System with Budgets and Impression TrackingMedium

  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.

  AttentiveSoftware EngineerSystem DesignOnsite
• Design a Reliable Third-Party Data Ingestion ServiceMedium

  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.

  AttentiveSoftware EngineerSystem DesignOnsite
• Design a Scalable Catalog ServiceMedium

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

  AttentiveSoftware EngineerSystem DesignOnsite
• Design a Snapshot-Driven Product CatalogMedium

  Design a multi-tenant product catalog ingestion and serving system that processes periodic, complete merchant snapshots while deterministically layering administrator overrides, supporting atomic cutovers, and maintaining read consistency.

  AttentiveSoftware EngineerSystem DesignOnsite
• Evaluate a Lisp-Style Prefix Expression Language With ADD, MULT and LET VariablesMedium

  Implement an evaluator for a small Lisp-style prefix language with ADD and MULT, then extend it with LET variable bindings. It tests recursive parsing of nested expressions, settling ambiguous language rules before coding, and choosing a data structure for nested variable scopes.

  AttentiveSoftware EngineerSoftware Engineering FundamentalsOnsite
• Evaluate a Scoped Lisp ExpressionMedium

  Implement a recursive descent or token-based interpreter to evaluate a scoped, Lisp-like arithmetic expression supporting addition, multiplication, and sequential variable bindings with shadowing.

  AttentiveSoftware EngineerCoding & AlgorithmsOnsite
• Explain switch to product analytics and company fitHard

  This question evaluates a data scientist's product analytics and leadership competencies, including end-to-end decision ownership, prioritization of product metrics, communicating trade-offs between statistical rigor and speed, and influencing stakeholders within a B2B mobile messaging context that has compliance and deliverability constraints.

  AttentiveData ScientistBehavioral & LeadershipTechnical Screen
• Find Inclusive Index Ranges for Time-Window Queries on Timestamp-Sorted LogsMedium

  Given log timestamps sorted in non-decreasing order with possible duplicates, answer many inclusive time-window queries by returning the first and last index of the entries inside each window, where a window may extend past the data's time range. It tests O(log n) per-query boundary searches on sorted data with duplicate keys.

  AttentiveSoftware EngineerCoding & AlgorithmsTechnical Screen
• Remove Adjacent Duplicate Runs of Length KMedium

  Implement a linear-time string reduction algorithm that repeatedly eliminates adjacent runs of k identical characters using a stack.

  AttentiveSoftware EngineerCoding & AlgorithmsTechnical Screen
• Return Log Entries Within an Inclusive Time Range From a Sorted LogMedium

  Given an in-memory log sorted by integer timestamp, return every entry whose timestamp lies within an inclusive start and end time. The problem tests exact boundary handling with duplicate timestamps, empty results when the range misses the log, and locating a range efficiently in sorted data.

  AttentiveSoftware EngineerCoding & AlgorithmsOnsite