Skip to content
Tech Interview Prep
Technical interview guide

Feature Stores

A shared, consistent source of features for both training and serving, avoiding train/serve skew.

Read
45 min
Practice MCQs
25
Interview Q&A
25
Edition
v4
Editorial status
Reviewed
Relevant for
MLOps Engineer

Scope: Feast, Amazon SageMaker Feature Store, Azure Machine Learning managed feature store, and NIST AI RMF guidance current 2026-09-01.

Curated: · Written: · Reviewed:

25 questions

MCQ-2A team backfills a training set from an offline feature table. For user 42, the label row has prediction_ts = 2024-03-10T00:00Z. The feature table holds three daily snapshots of spend_30d for user 42: (event_ts 2024-03-01, 40), (event_ts 2024-03-09, 90), (event_ts 2024-03-12, 170). A point-in-time-correct join returns which value for this row?
MCQ-10A fraud model is trained by joining each label to the offline store's `spend_7d` history. To stay point-in-time correct, a training row may only carry the feature value as it stood at the label's timestamp: never a value written after it. The offline store holds: | user_id | event_timestamp | spend_7d | | --- | --- | --- | | u1 | 2024-03-01T00:00Z | 120 | | u1 | 2024-03-05T00:00Z | 340 | | u1 | 2024-03-06T00:00Z | 275 | | u1 | 2024-03-09T00:00Z | 90 | | u2 | 2024-03-04T00:00Z | 60 | For the label row (user_id=u1, label_ts=2024-03-06T00:00Z, is_fraud=1), which spend_7d value belongs in the training row, and what would a join that simply takes the newest row per user produce instead?
MCQ-3A fraud team builds training rows from decisions made in March 2024. The feature table `user_txn_count_7d` is keyed by user_id and carries an event_timestamp. User 42 has two rows: (2024-03-05, 3) and (2024-04-02, 41). User 42's label row is a decision at 2024-03-06. The engineer joins labels to features on user_id only and keeps the latest row per user. What lands in user 42's training row?
MCQ-25A fraud model reads user_txn_count_24h from a feature store. Offline, a nightly Spark job builds the table by grouping events on the request row's event_date and joins labels at request_time; the table is kept in Iceberg and training history goes back two years. Online, a Flink job keeps a sliding 24-hour window per user in Redis under a 7-day TTL. Offline validation reports AUC 0.91, production 0.74. Monitoring shows 18% of scored users read 0 online while the matching training row was above 0, and every traced case counts a transaction that landed after the request_time, for instance a request at 2024-03-05T09:00 whose training row counted a 2024-03-05T15:40 transaction. Which action makes the offline table agree with what the model can know at scoring time?
MCQ-5A feature store keeps every version of the feature `days_past_due_max` for a loan account, each tagged with the event time of the servicing update and the ingestion time at which the store learned it: | version | event_time | ingest_time | value | | --- | --- | --- | --- | | v1 | 2024-04-20 | 2024-04-21 | 0 | | v2 | 2024-04-20 | 2024-05-03 | 30 | | v3 | 2024-04-28 | 2024-04-29 | 0 | | v4 | 2024-04-28 | 2024-05-10 | 15 | A training example is built for an application decided at 2024-05-01T00:00Z; its label (default within 90 days) is observed at the end of July. The team wants the offline feature value to equal what the model would have seen online at the decision instant. Which value should the training row carry?
MCQ-8A team builds a training set by joining labels to features from the offline store. The offline store is materialized nightly at 00:00; each row is keyed by (user_id, date) and holds the feature value as of 00:00 that day. A label at 14:00 on day D is joined to the row for day D. Both the offline and online stores are built from the same event log. The model trains to AUC 0.88 offline but scores 0.69 in production, where the online store serves the current value at request time. For a user who made a large purchase at 13:00 on day D, the offline row for day D shows `spend_7d = 50` and the online value at 14:00 shows `spend_7d = 550`. What is the cause of the training-serving skew?
MCQ-1A fraud model scores 0.86 AUC offline, but in production precision at a 1% alert rate is 0.44 against 0.71 measured offline. Training rows come from a nightly Spark job that, for each labelled transaction at time t, counts the card's chargebacks in the 30 days before t. The online scorer calls a feature service backed by a Redis counter that is incremented on each chargeback, expires after 7 days, and is reset by a nightly job at 00:00 UTC. For one card with 4 chargebacks in the last 30 days (3 in the last 7 days, 1 since 00:00 UTC) the training row holds 4 and the online call returns 1. Which change closes the gap?
MCQ-21Team A publishes `merchant_chargeback_rate_30d` to an online feature store. A nightly job recomputes every merchant's rate over the 30 days ending at run time and swaps the table in a single atomic write at 02:00 UTC; the online store serves the most recent completed write. Team B reuses the feature in a real-time authorization model and builds its training set by joining the offline table to each transaction on the transaction's date. Offline validation AUC is 0.88; in production the same model scores 0.64, and the gap is concentrated in transactions between 00:00 and 02:00 UTC. Traffic is roughly uniform across the day. What explains the gap?
MCQ-9A feature `user_7d_click_rate` (definition v3) is served from Redis, written by a streaming job that keeps a 7-day window over the click stream. The offline copy is an Iceberg table partitioned by `event_date`; a job at 01:00 UTC recomputes each user's rate over the seven most recent complete `event_date` partitions. A parity job at 10:00 UTC samples 50,000 users, fetches the online value, and compares it to the offline row for `event_date = yesterday`. 3,100 users (6.2%) mismatch, the online value is higher in every one, and all mismatched users have clicks between 00:00 and 10:00 UTC today. What should the team change?
MCQ-7A fraud model uses the per-user feature `avg_order_value_30d`. Offline, a nightly Spark job averages `order_amount` over the trailing 30 days ending at each label's timestamp and excludes orders with `status = 'cancelled'`; the offline mean is $54.00 and offline AUC is 0.91. Online, a Flink job keeps a running sum and count per user over a 30-day window and divides them, including every order; the online mean is $50.00 and online AUC is 0.74. Cancelled orders are 8% of all orders and average $4.00. Which explanation fits the numbers?
MCQ-23When generating historical training datasets via point-in-time 'as-of' joins across high-frequency entity observation logs, what is the primary computational bottleneck for query engines like Spark, Snowflake, or BigQuery?
MCQ-4A payments stream carries two timestamps per record: `event_ts` (when the terminal authorized the charge) and `ingest_ts` (when the collector wrote it to the log). A tumbling 5-minute job currently buckets by `ingest_ts`. Five records arrive: | record | event_ts | ingest_ts | | --- | --- | --- | | e1 | 10:01:10 | 10:01:12 | | e2 | 10:04:50 | 10:04:52 | | e3 | 10:02:30 | 10:06:40 | | e4 | 10:05:20 | 10:05:22 | | e5 | 10:05:00 | 10:05:01 | The team switches the job to bucket by `event_ts`. Which records does the [10:00, 10:05) bucket contain?
MCQ-22A streaming job maintains the online feature `txn_count_1h` per card in Redis: it runs `INCR` on the card's key for every transaction event, and a scheduled job deletes each key at the top of the hour. The job also appends every event to an offline store used for training. Card C's key was deleted at 10:00:00. At 10:00:04 an event for card C arrives with event_time 09:58:12, and the job's current code runs `INCR`, leaving the online value at 1. What should the job do with this event?
MCQ-6A ranking service must answer in 50 ms p99 and needs 150 features for one user. The online feature store is a Redis cluster that holds each feature as a separate key; a 150-key `MGET` returns in 6 ms p99, and a single `GET` returns in 4 ms p99. The serving code fetches the features with 150 `GET` calls, each awaited before the next. What p99 does the feature fetch add?
MCQ-13An online feature store serves `user_spend_1h` to a fraud model. The feature view's TTL is 30 days. The hourly job that writes the feature has been failing for 5 days, so the newest stored value has an event timestamp 5 days old. Requests keep arriving. What does the serving path return for this feature?
MCQ-11An hourly job materializes the `user_activity_7d` feature (12.0M keys) into Redis. Each run reads the last 7 days from the warehouse and overwrites all 12.0M keys; a healthy run takes about 5 minutes and writes 12.0M rows. Overnight the upstream warehouse load failed, so the 02:00–08:00 partitions were empty. The 02:00 materialization run read 0 rows, wrote 0 rows, and exited 0 in 5 minutes. The orchestrator shows 7/7 green runs, and Redis keeps serving keys stamped `materialized_at = 01:00`. Which check would have fired by 02:05?
MCQ-14A fraud model consumes `txn_count_7d` from a feature store. In training the feature is never missing and ranges from 0 to 340. At serving time the store writes 0 whenever the hourly aggregation job has not yet produced a value for a user. On a day when that job stalled for 90 minutes, 7% of scoring requests received 0, and the feature's null-rate dashboard stayed green throughout. What does this setup produce?
MCQ-15An online loan-default model reads `income_monthly` from the feature store. After a pipeline release, AUC on a frozen holdout drops from 0.81 to 0.62. Serving telemetry for `income_monthly` shows p50 = 5,400 and p99 = 42,000; the training snapshot for the same feature shows p50 = 54 and p99 = 420. The model registry records only the feature name and the online-store endpoint. What does the evidence indicate?
MCQ-16A feature platform stores feature definitions and materializes them to an online store every hour. `driver_conv_rate` is defined as `SUM(completed) / SUM(offered)` over a driver's full history, and two production models trained on those full-history values read it. On Monday an engineer edits that same definition in place, the platform accepts the edit as an additive schema change, to the same ratio over a trailing 7-day window, then backfills the offline store. For driver D, full history is 900/1000 and the trailing 7 days are 40/50. The pricing model rejects any driver whose `driver_conv_rate` is below 0.85. After the next hourly materialization, what does the pricing model see for D, and what is the defect?
MCQ-17A feature store serves two tenants from one online store: a single key-value map keyed by the entity key string, where a write replaces the stored row only if its event timestamp is greater than the stored row's. Both tenants use user_id as the entity, so both write the key `user_id:4471`. Tenant A's user 4471 has plan_tier=free with event timestamp 09:58:00; tenant B's user 4471 has plan_tier=enterprise with event timestamp 09:59:00. A's row is materialized at 10:00:01 and B's at 10:00:05. At 10:01, tenant A's model reads user 4471. What does it receive?
MCQ-12A nightly job materializes `user_30d_click_count`. For each day in the window it computes each user's click delta, calls `INCRBY feat:u:{id}:clicks30d <delta>` on the online store, then `INSERT INTO offline.feature_clicks PARTITION(event_date)`. A 30-day backfill dies from an OOM at 03:40 after finishing days 1–12; an operator re-runs the identical job for the same 30-day window and it completes. What do the two stores hold afterward?
MCQ-18A fraud-scoring service reads 40 features per transaction from an online feature store. The store is down and every read fails. The service keeps a local cache of the last successful feature vector per user: 92% of entries are under 10 minutes old, the rest older. Model precision is 0.71 on features up to 15 minutes stale and 0.44 beyond that. Every request must return within 300 ms, and the offline store answers a point lookup in 4-9 s. Transactions of $500 or more carry chargeback liability. Which fallback should the service use while the store is down?
MCQ-19An ML platform stores user features in an Iceberg table, `features`, that uses merge-on-read row-level deletes, serves them from Redis under key `f:{user_id}` by an hourly materializer, and appends (user_id, vector) rows to a separate `training_logs` table retained 90 days. A weekly job expires `features` snapshots older than 30 days and then removes orphan files; nothing else expires snapshots or deletes logged vectors. A deletion request for user 4021 arrives, the on-call engineer deletes the Redis key, runs DELETE FROM features WHERE user_id = 4021, and confirms that query now returns zero rows. Which copies can still return that user's feature values?
MCQ-24`recs_v1` is a feature table. The serving path stopped reading it on 2024-05-15, and the dashboard shows zero reads since. A nightly job `recs_export` still reads `recs_v1` at 02:00 UTC. The last write to `recs_v1` was 2024-06-01. Audit policy requires the table to be retained for 90 days after its last write. Today is 2024-06-20. What is the correct next step for retiring `recs_v1`?
MCQ-20A fraud model scores 4,000 transactions/min behind a feature store. On Tuesday its live precision fell from 0.82 to 0.61, while an offline replay over the same day's labelled transactions still scores 0.82. Two changes shipped that morning: the model was retrained, and the upstream job feeding the `merchant_risk_30d` feature moved from hourly to daily refresh. The prediction log records the score, the model version, and the request timestamp. The feature store keeps point-in-time values for 7 days, and this incident is being reviewed on day 10. What should the log record per prediction so that a drop like this can be attributed to one of the two changes?