{
 "schemaVersion": 1,
 "pathSlug": "green-but-wrong",
 "items": [
  {
   "questionId": "data_pipelines.orchestration__68296",
   "topic": "data_pipelines",
   "subSkill": "orchestration",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the purpose of task pools in orchestration?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Limiting concurrent task execution to prevent overwhelming shared resources"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "They pre-allocate compute resources for tasks"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Pools group related tasks for display purposes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Pools store task output data"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.orchestration__68325",
   "topic": "data_pipelines",
   "subSkill": "orchestration",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the impact of DAG complexity on scheduler performance?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Deeply nested DAGs push the scheduler's parse step onto the worker that runs each task"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Highly complex DAGs with many tasks increase scheduling latency and memory consumption"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Task complexity is absorbed by the executor, so the scheduler's cost stays flat with size"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A DAG's task count sets how many scheduler replicas the deployment has to run at once"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.orchestration__826394",
   "topic": "data_pipelines",
   "subSkill": "orchestration",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dev writes a custom sensor that polls an API every 30s for hours. The Airflow worker pool is exhausted and other DAGs queue. The sensor logic is fine. What sensor mode change avoids holding a worker slot the whole time?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "wait = HttpSensor(task_id='wait', http_conn_id='api', endpoint='ready', poke_interval=30)",
    "label": "orchestration.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Set mode='persistent' so the sensor keeps state in XCom and only occupies a slot during state changes"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Set mode='reschedule' so the sensor releases its slot between pokes instead of sleeping while occupying a worker"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Set mode='soft_fail' so the sensor frees its slot after the first poke regardless of the result returned"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Set mode='deferred_legacy' so the sensor downgrades to a cron entry once it has run for over an hour"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.orchestration__2010417",
   "topic": "data_pipelines",
   "subSkill": "orchestration",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes Airflow's BranchPythonOperator semantics?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It runs every downstream task in parallel and afterwards prunes the outputs whose flag did not match"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It blocks the run until an operator user confirms which branch to take through the web UI dropdown"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It returns one or more downstream task ids to follow and the scheduler skips the unselected branches"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It writes a row to the metadata DB and a separate scheduler tick decides which branch is dispatched"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.orchestration__68355",
   "topic": "data_pipelines",
   "subSkill": "orchestration",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the theoretical tradeoff between scheduling optimality and scheduling speed?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Finding the globally optimal schedule is undecidable, so a scheduler samples random orderings and keeps the best one it finds"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Finding the globally optimal schedule takes polynomial time once the DAG is acyclic, so a heuristic gives up optimality without buying speed"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Finding the globally optimal schedule is NP-hard; practical schedulers use heuristics that trade optimality for speed"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Finding the globally optimal schedule is linear in the task count; the cost sits in the metadata writes each decision needs"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.orchestration__2010432",
   "topic": "data_pipelines",
   "subSkill": "orchestration",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which characterisation fits Airflow's deferrable operator pattern with the triggerer process?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Long waits release the worker slot and resume on a separate async loop once the trigger event fires"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Long waits are converted to schedule-only sleeps that pause the entire DAG run until the wake moment"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Long waits send a request to a sibling DAG that holds the wait condition and wakes the original run"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Long waits continue to occupy a worker slot but suspend their thread inside the executor heartbeat tick"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.orchestration__200206",
   "topic": "data_pipelines",
   "subSkill": "orchestration",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How do Prefect flows differ from Airflow DAGs in how the dependency graph is expressed in user code?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Prefect derives dependencies from Python function calls and return values at runtime, no static DAG file"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Prefect requires a YAML DAG manifest at parse time and forbids using normal Python function call edges"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Prefect and Airflow both compile a static graph from decorators only and forbid runtime call inference"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Prefect rejects any function-call style and requires a static graph compiled before each scheduler run"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.orchestration__7116842",
   "topic": "data_pipelines",
   "subSkill": "orchestration",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "In modern Airflow, what behavior does the deferrable=True flag enable on a sensor or operator?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The task suspends on a Trigger handled by the triggerer process, freeing its worker slot until the event fires"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The task is moved to the smart_sensor service so that one process can poll many sensor instances at once instead"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The task is rescheduled with mode='reschedule', releasing the slot but rerunning poke from scratch each time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The task is queued on a celery_kubernetes hybrid executor that allocates pods for long waits"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.orchestration__68294",
   "topic": "data_pipelines",
   "subSkill": "orchestration",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is idempotency in the context of orchestrated tasks?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A task that holds a lock so that two runs of it cannot overlap in time"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A task that the scheduler guarantees to launch exactly once per interval"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A task that writes its output before it acknowledges the upstream trigger"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A task that produces the same result regardless of how many times it runs"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.orchestration__68333",
   "topic": "data_pipelines",
   "subSkill": "orchestration",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does event-driven orchestration differ from traditional scheduling?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The consumer subscribes to the producer's graph, so the two run as one larger workflow"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "An event from the producer starts the work downstream, so no polling is needed"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A timer starts the work downstream, and each event from the producer waits until it fires"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The scheduler reads the storage layer directly, so a file landing is what triggers a run"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "postgresql.json_operations__400766",
   "topic": "postgresql",
   "subSkill": "json_operations",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes how "
      },
      {
       "t": "code",
       "v": "jsonb_pretty"
      },
      {
       "t": "text",
       "v": " renders a stored document?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Produces a binary-safe text form with escape sequences covering every non-ASCII scalar byte"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Produces a compressed text form using backreferences to deduplicate repeated key strings"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Produces a canonical text form that sorts keys and strips whitespace for stable hashing use"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Produces text with indentation and line breaks arranged for human reading only"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.json_operations__2256862",
   "topic": "sql",
   "subSkill": "json_operations",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How is a calendar date normally represented in a JSON document?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "as a native date value built into JSON"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "as a special dollar-prefixed keyword"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "as an integer count of calendar months"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "as a string, since JSON has no date type"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.json_operations__2256848",
   "topic": "sql",
   "subSkill": "json_operations",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "In standard JSON, how must each member name inside an object be written?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "enclosed in square brackets"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "enclosed in parenthesis marks"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "enclosed in single quotes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "enclosed in double quotes"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "postgresql.json_operations__304414",
   "topic": "postgresql",
   "subSkill": "json_operations",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "You need to test whether any item matched by a jsonpath exists in a jsonb document, as an SQL boolean operator (not a function call). Which operator does the job?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "@@"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "@>"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "@?"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "?|"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "postgresql.json_operations__52267",
   "topic": "postgresql",
   "subSkill": "json_operations",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "When using a GIN index with jsonb_path_ops on a JSONB column, which of these queries can the index accelerate?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "WHERE data @> '{\"status\": \"active\"}'"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "WHERE data ?| array['status', 'name']"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "WHERE data ? 'status'"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "WHERE data ?& array['status', 'name']"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "postgresql.json_operations__61196",
   "topic": "postgresql",
   "subSkill": "json_operations",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How do you count the number of keys in a JSONB object?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "SELECT count(*)\nFROM jsonb_object_keys(\n  '{\"a\": 1, \"b\": 2, \"c\": 3}'::jsonb\n);\n-- 3",
    "label": "json-operations.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Use jsonb_length() on the object as you would on a JSONB array to return the count of its keys"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Use the # operator with no operand to return the cardinality of the document's top-level key set"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Use jsonb_object_keys() in a subquery with count(), or cast to text and use array functions"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Use the built-in jsonb_count_keys() function on the JSONB object directly to get an integer count"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "postgresql.json_operations__2059724",
   "topic": "postgresql",
   "subSkill": "json_operations",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the final result?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "SELECT jsonb_set(\n  '{\"k\": \"v\"}'::jsonb || '{\"n\": [1, 2, 0]}'::jsonb,\n  '{n,-1}',\n  '3'::jsonb\n);",
    "label": "json-operations.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "{\"k\": \"v\", \"n\": [1, 2, 3]}"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "{\"k\": \"v\", \"n\": [1, 2]}"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "{\"n\": [1, 2, 3], \"k\": \"v\"}"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "{\"k\": \"v\", \"n\": [3, 1, 2]}"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "sql.json_operations__248970326276",
   "topic": "sql",
   "subSkill": "json_operations",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "On PostgreSQL 16, the minus operator is applied to a jsonb array with an integer operand and to a jsonb object with a text operand: '[10,20,30]'::jsonb - 1 and '{\"a\":1,\"b\":2}'::jsonb - 'a'. What does each call remove?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "the array call removes the member whose key is a, the object call removes the element at position 1"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "both calls remove whatever operand is passed regardless of whether it names a position or a key"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "the array call removes the element at position 1, the object call removes the member whose key is a"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "the array call raises an error because the minus operator only accepts a jsonb value as its right operand"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "sql.json_operations__1277",
   "topic": "sql",
   "subSkill": "json_operations",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which mechanism is documented for confirming that a string column or parameter contains well-formed JSON before further processing?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "-- MySQL\nSELECT * FROM raw_events\nWHERE JSON_VALID(payload) = 1;\n\n-- SQL Server\nSELECT * FROM raw_events\nWHERE ISJSON(payload) = 1;",
    "label": "json-operations.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A call to "
       },
       {
        "t": "code",
        "v": "JSON_PARSE"
       },
       {
        "t": "text",
        "v": " whose return value can be inspected to distinguish well-formed input from malformed input"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Built-in predicates: "
       },
       {
        "t": "code",
        "v": "ISJSON"
       },
       {
        "t": "text",
        "v": " in SQL Server, "
       },
       {
        "t": "code",
        "v": "JSON_VALID"
       },
       {
        "t": "text",
        "v": " in MySQL, or an explicit cast to "
       },
       {
        "t": "code",
        "v": "jsonb"
       },
       {
        "t": "text",
        "v": " wrapped in error handling in PostgreSQL"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A typed JSON column rejects ill-formed text on insert without any predicate, so callers can rely on the column type alone for cleanup"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A regex pattern in a "
       },
       {
        "t": "code",
        "v": "CHECK"
       },
       {
        "t": "text",
        "v": " constraint, since well-formed JSON is a regular language across nesting depths and quotes"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "sql.json_operations__621691334153",
   "topic": "sql",
   "subSkill": "json_operations",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "On PostgreSQL 16, jsonb_insert is used to place a new element into the array [1,3] at index 1, once with the default fifth argument and once with insert_after set true. How do jsonb_insert and jsonb_set differ in what they do to an existing element at that index?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "jsonb_insert and jsonb_set both overwrite the existing element in place and differ only in their argument order"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "jsonb_insert overwrites the existing array element in place, jsonb_set shifts the existing element aside and adds the new one right next to it"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "jsonb_insert and jsonb_set both shift the existing element aside and differ only in which side they insert on"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "jsonb_insert shifts the existing element aside and adds the new one next to it, jsonb_set overwrites the existing element in place"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "sql.subqueries__200132",
   "topic": "sql",
   "subSkill": "subqueries",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes a non-correlated (uncorrelated) subquery?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A nested SELECT that must always be rewritten into an inner join shape"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A nested SELECT permitted only inside the WHERE clause of a statement"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A nested SELECT returning the same column lineage as the outer relation"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A nested SELECT whose result is independent of any outer query row"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.subqueries__479364780117",
   "topic": "sql",
   "subSkill": "subqueries",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "On PostgreSQL 16, the same query is rerun with WITH big AS MATERIALIZED (...), and the plan changes to a Nested Loop over a CTE node labeled CTE big, feeding a CTE Scan and an Index Only Scan on customers. What does adding MATERIALIZED force here?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "EXPLAIN (COSTS OFF)\nWITH big AS MATERIALIZED (SELECT * FROM orders WHERE amount > 50)\nSELECT c.id FROM customers c WHERE c.id IN (SELECT customer_id FROM big);",
    "label": "subqueries.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "the CTE runs once as a separate step and the outer query reads its output through a CTE Scan"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "the CTE gets discarded and the outer query falls back to reading the base table under this plan shape"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "the CTE forces the outer query onto a sequential scan of the customers table under this plan shape"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "the CTE runs again once per outer row through a correlated CTE Scan node each time under this plan shape"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "sql.subqueries__382256197487",
   "topic": "sql",
   "subSkill": "subqueries",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A statement fails with an error stating a subquery must return only one column, and the subquery sits inside a scalar position in the SELECT list. What change to that nested query resolves the failure?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "dropping the inner query's projection down to a single column"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "adding a LIMIT clause onto the inner query's projection list"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "wrapping the inner query's projection inside a DISTINCT clause"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "adding an ORDER BY clause onto the inner query's column projection list"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.subqueries__903065805277",
   "topic": "sql",
   "subSkill": "subqueries",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Placing a subquery in a WHERE clause versus placing it in the SELECT list changes what the subquery's result is used for. What is that difference?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "sorting the outer rows by a shared grouping key rather than filtering them against a value"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "filtering rows against testing membership instead of producing an extra output column"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "renaming the outer table rather than aliasing the join condition it depends on"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "locking every outer row until the whole surrounding transaction finally commits and releases it"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "sql.subqueries__1693425",
   "topic": "sql",
   "subSkill": "subqueries",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What role do the parentheses around a subquery play?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "They cache the nested query result for later reuse"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "They convert the nested query into a real index"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "They mark where the nested query starts and ends"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "They force the nested query to run in parallel"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.subqueries__737",
   "topic": "sql",
   "subSkill": "subqueries",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does ALL do with a subquery?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Returns true only if the comparison is true for every value in the subquery result"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Returns all rows without filtering"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Computes the comparison for the first row only"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Selects all columns from the subquery"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.subqueries__1075062604056",
   "topic": "sql",
   "subSkill": "subqueries",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A named result set defined with a WITH clause before the main statement, so the main statement can read it by name, is called what?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "a function returning a table"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "a common-table expression"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "a temp table from one DDL run"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "a view under its own name"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.subqueries__730",
   "topic": "sql",
   "subSkill": "subqueries",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a derived table?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "SELECT u.name, oc.order_count\nFROM users u\nJOIN (\n  SELECT user_id, COUNT(*) AS order_count\n  FROM orders\n  GROUP BY user_id\n) AS oc ON oc.user_id = u.id;",
    "label": "subqueries.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A subquery used in the FROM clause that acts as a temporary table for the outer query"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A table derived from a mathematical formula"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A table created by the database automatically"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A table that inherits columns from a parent table"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.subqueries__973229507535",
   "topic": "sql",
   "subSkill": "subqueries",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "SELECT * FROM (SELECT id FROM customers LIMIT 3) sub returns how many rows against the customers table set up for this batch?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "SELECT * FROM (SELECT id FROM customers LIMIT 3) sub;",
    "label": "subqueries.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "a single row holding all three id values joined"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "zero rows returned, filter needed on the outer"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "three rows, each holding one customer id column"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "three rows total, each one holding a customer column"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.subqueries__100474",
   "topic": "sql",
   "subSkill": "subqueries",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "MySQL 8.0.32+ keeps tightening rewrites of IN/EXISTS subqueries. Which optimizer flag, controllable via optimizer_switch, governs whether a correlated EXISTS is unnested into a join-style execution?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "unnest=on"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "exist_in=on"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "anti_only=on"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "semijoin=on"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "sql.joins__700",
   "topic": "sql",
   "subSkill": "joins",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which clause combines rows from two tables based on a matching column predicate?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "JOIN"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "LINK"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "MERGE"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "COMBINE"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.joins__705428227346",
   "topic": "sql",
   "subSkill": "joins",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A LEFT JOIN from customers to orders filters on order amount by placing the condition inside the ON clause in one version of a query, and inside a WHERE clause added after the join in a second version. How do the two row counts compare for a customer whose only order fails that amount filter?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "both versions keep that customer with a null order attached"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "the ON version keeps that customer, the WHERE version drops it"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "the WHERE version keeps that same customer, the ON version drops it"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "both versions drop that customer from the final result set"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.joins__416943",
   "topic": "sql",
   "subSkill": "joins",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How many rows does the query produce?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "-- cust(id): 1,2\n-- orders(cust_id,total):\n--   (1,9),(1,8),(1,7),(2,5),(2,4),(2,3)\nSELECT c.id, t.total\nFROM   cust c\nCROSS  JOIN LATERAL (SELECT total FROM orders\n                     WHERE cust_id = c.id\n                     ORDER BY total DESC\n                     FETCH FIRST 2 ROWS ONLY) t;",
    "label": "joins.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "8"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "2"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "6"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "4"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.joins__10281",
   "topic": "sql",
   "subSkill": "joins",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What happens when a JOIN condition produces multiple matches?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The last match overwrites all of the previous match rows"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Only the first match is kept per each left table row"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "One output row for each combination of matching left and right rows"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "An error is thrown by the database engine on duplicates"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.joins__541",
   "topic": "sql",
   "subSkill": "joins",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A query writes "
      },
      {
       "t": "code",
       "v": "FROM a NATURAL JOIN b"
      },
      {
       "t": "text",
       "v": " with no explicit predicate. Which rule does the engine apply to match rows?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Matches rows by physical storage order rather than by any column value"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Matches columns with the same name in both tables, no explicit ON needed"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Matches columns linked by declared foreign-key constraints between the tables"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Matches whichever pair of columns the optimizer estimates to be the cheapest"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.joins__983618",
   "topic": "sql",
   "subSkill": "joins",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "If you write just "
      },
      {
       "t": "code",
       "v": "JOIN"
      },
      {
       "t": "text",
       "v": " with no word in front of it, which join type do you get?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "INNER JOIN"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "OUTER JOIN"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "CROSS JOIN"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "FULL JOIN"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.joins__500673",
   "topic": "sql",
   "subSkill": "joins",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the semantics of a partitioned outer join (PARTITION BY inside an outer join, as in Oracle)?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Hash-partitions both inputs by the group key and runs an inner join per partition, padding empty partitions later."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Pivots the right input across a categorical column and joins each pivoted column to the outer side independently."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Aggregates the right input by an explicit grouping set and joins each aggregate row to the matching outer key once."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Densifies a left input by emitting a row per group key from a partitioning expression, even when no match exists."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "sql.joins__300452",
   "topic": "sql",
   "subSkill": "joins",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the correct characterization of a LATERAL join in standard SQL?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The right-hand subquery is evaluated once and then broadcast horizontally across each row of the left FROM item."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The right-hand subquery is rewritten into a UNION ALL of two halves so the planner can prune one side per row."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The right-hand subquery may reference columns from preceding FROM items, evaluated row-by-row as a correlated input."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The right-hand subquery is forced to materialize before the left side, with the left input probing the cached result."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "sql.joins__10276",
   "topic": "sql",
   "subSkill": "joins",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which technique lets one query compare rows within a single table - for example, listing each employee next to their manager?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "SELECT e.name AS employee, m.name AS manager\nFROM employees e\nJOIN employees m ON e.manager_id = m.id;",
    "label": "joins.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Joining the table to itself using two distinct correlation aliases"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Joining two identical database server instances over a network link"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A join that automatically generates matching row data on demand"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Joining the table to a backup copy refreshed before each query"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "sql.joins__400562",
   "topic": "sql",
   "subSkill": "joins",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the role of join order in a query plan, holding predicates and indexes constant?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Reordering may change the final result row count whenever the inputs include outer joins or aggregate clauses."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Reordering is forbidden by the standard once an index hint or query plan directive is attached to a base table."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Reordering can change intermediate cardinalities, hash-build sizes, and overall cost without altering the result."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Reordering changes the projection list of the output, so column ordinal positions are tied to the FROM clause."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.change_data_capture__68473",
   "topic": "data_pipelines",
   "subSkill": "change_data_capture",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the purpose of watermarks in CDC sink processing?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Marking the point past which the source database can safely recycle the write-ahead log segments it still retains on disk"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Buffering out-of-order events until the sink can apply each row's changes in strict commit sequence"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Recording the wall-clock lag between a source commit and its arrival at the sink so alerting can fire on it"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Tracking how far the sink has progressed in applying CDC events, enabling efficient incremental queries on the target"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.change_data_capture__400563",
   "topic": "data_pipelines",
   "subSkill": "change_data_capture",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Comparing topic-per-table CDC routing against single-topic-with-key-by-PK routing for a 2,000-table source, which difference dominates the long-term operational picture?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Topic-per-table forces every consumer to subscribe to every topic, which one-topic-many-tables avoids by routing changes to the right partition"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Topic-per-table makes per-table retention, ACLs, and replay tractable, while one-topic-many-tables forces consumers to filter every event and complicates compaction by key"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Topic-per-table is the only configuration in which Debezium can enforce schema compatibility, since the registry binds compatibility to topic"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Topic-per-table breaks Kafka ordering guarantees on the primary key, while one-topic-many-tables preserves global order across all source tables"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.change_data_capture__68477",
   "topic": "data_pipelines",
   "subSkill": "change_data_capture",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the role of CDC in an ODS architecture?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It feeds live changes from the operational databases into a store that integrates several sources"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It reads the integrating store on a schedule and pushes the differences back to each source system"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It replaces the integrating store, since the change stream itself is the record other systems read"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It archives the integrating store into the lake, so the operational databases can be trimmed back"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.change_data_capture__400570",
   "topic": "data_pipelines",
   "subSkill": "change_data_capture",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A schema-change event carries op='alter' and a new column. The downstream sink validates the post-change payload against a frozen schema and rejects unknown fields. What does the snippet print?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "schema = {'pk','name'}\nevent = {'pk':1,'name':'a','region':'eu'}\nunknown = set(event) - schema\nif unknown:\n    print(f\"rejected: unknown field '{next(iter(unknown))}'\")\nelse:\n    print('accepted')",
    "label": "change-data-capture.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "accepted: unknown field ignored"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "accepted: schema auto-evolved"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "rejected: missing field 'region'"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "rejected: unknown field 'region'"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.change_data_capture__68491",
   "topic": "data_pipelines",
   "subSkill": "change_data_capture",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does CDC handle encryption-at-rest in the source database?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The logical decoding plugin re-encrypts each change event with the connector's own public key before the event leaves the database process"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The connector reads the encrypted WAL bytes and defers decryption to the sink, which holds the target system's own key material"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Encryption at rest forces the connector onto trigger-based capture, since the WAL becomes unreadable to a logical replication slot"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "If the database encrypts its WAL, the CDC connector must have access to decryption keys or read from an unencrypted replication stream"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.change_data_capture__200445",
   "topic": "data_pipelines",
   "subSkill": "change_data_capture",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A Kafka Connect sink writes CDC events into the warehouse. Operators see duplicate rows after a connector restart, and the sink topic was configured for at-least-once delivery. What sink-side change addresses the duplicates?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Apply changes via an idempotent upsert keyed on the source primary key plus the LSN or offset"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Enable the sink's exactly-once profile by setting transaction.timeout above the broker timeout"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Switch the sink connector to fire-and-forget delivery so retries do not replay the same offsets"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Reduce the connector's max.poll.records so each Kafka poll batch fits inside one warehouse txn"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.change_data_capture__68489",
   "topic": "data_pipelines",
   "subSkill": "change_data_capture",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does CDC enable time-travel queries on operational data?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The consumer takes a snapshot each night, from which an earlier day can be reconstructed"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The events are kept in an appended log with timestamps, so a state can be rebuilt"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The source keeps its own history, and the capture merely reports which rows have changed"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The events are kept in a table that is updated in place, so the newest state is at hand"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.change_data_capture__68437",
   "topic": "data_pipelines",
   "subSkill": "change_data_capture",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a CDC event envelope?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A structured message carrying the record as it now stands, with no history of that one change"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A structured message carrying the record before and after the change, plus metadata about it"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A schema registry entry describing the shape each change event on that topic will take"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A wrapper the connector adds so the broker can route the message to the right consumer"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.change_data_capture__68503",
   "topic": "data_pipelines",
   "subSkill": "change_data_capture",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does CDC support regulatory compliance for data retention?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "CDC events carry a retention clock, so records past their legal retention window are purged from the log automatically"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "CDC's append-only event log provides a complete, immutable audit trail of every change for compliance purposes"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Retention rules are satisfied by the source database's point-in-time backups, which CDC then mirrors to the archive"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Compliance is met by snapshotting the current table state nightly, which CDC schedules on the auditor's behalf"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.change_data_capture__68488",
   "topic": "data_pipelines",
   "subSkill": "change_data_capture",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the challenge of CDC in a multi-master database topology?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Changes from separate masters are already merged by the engine, so the capture sees one stream"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Changes from separate masters arrive with no primary key, so the consumer cannot match rows up"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Changes from separate masters cannot be read at once, since one slot serves the whole cluster"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Changes from separate masters have to be deduplicated and ordered, and conflicts captured too"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.stream_processing__742681",
   "topic": "data_pipelines",
   "subSkill": "stream_processing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dev sets processing.guarantee=exactly_once_v2 in Kafka Streams. They produce records to the source topic without transactions enabled on the producer. The Streams job runs but they see consumers downstream occasionally see records that the Streams app later retracts. What is happening?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Downstream consumers must use isolation.level=read_committed; otherwise they observe records inside open transactions before commit or abort."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Read-committed mode is implied by exactly-once-v2 on Streams' embedded consumers, so external consumers ignore that flag and see all uncommitted records."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Streams transactions only commit when the input source topic has min.insync.replicas set to one less than the total replication factor on each broker."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Exactly-once-v2 needs the source topic's producer to also be transactional, since broker-level idempotence does not extend across consumer-then-produce loops."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.stream_processing__100021",
   "topic": "data_pipelines",
   "subSkill": "stream_processing",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Given the Kafka Streams topology below, what is printed for the input record (key='a', value='hello world')?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "StreamsBuilder b = new StreamsBuilder();\nKStream<String,String> in = b.stream(\"in\");\nin.mapValues(v -> v.length())\n  .foreach((k,v) -> System.out.println(k + \" -> \" + v));",
    "label": "stream-processing.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "a -> 11"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "a -> 5"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "a -> 10"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "a -> 2"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.stream_processing__200634",
   "topic": "data_pipelines",
   "subSkill": "stream_processing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A Spark Structured Streaming job's micro-batch duration grows from 2s to 30s over a few hours. The query plan is unchanged. Driver UI shows 'numRowsDroppedByWatermark=0' and stable input rate. What is the most likely culprit?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Trigger interval was set lower than the source ingestion rate, queueing micro-batches forever"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Checkpoint location is on slow object storage which throttles offset commits between batches"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Adaptive query execution coalesced too few partitions, serialising the shuffle stage entirely"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Stateful aggregation accumulates entries because the watermark is too lax and state never expires"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.stream_processing__68263",
   "topic": "data_pipelines",
   "subSkill": "stream_processing",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a changelog topic's role in stateful stream processing?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It keeps the offsets each consumer committed, so progress survives a rebalance"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It keeps the input events as a compacted log, from which a restart replays them"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It keeps the output events for downstream consumers that fell behind the producer"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It keeps the operator state as a compacted log, from which a restart restores it"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.stream_processing__68226",
   "topic": "data_pipelines",
   "subSkill": "stream_processing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a changelog stream?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A stream that holds the schema history of a table, so a reader can parse an older event"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A stream whose events each record a change to one keyed record, insert, update or delete"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A stream whose events each carry the whole record as it stands after the change was made"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A stream of the offsets a consumer has committed, from which its progress can be tracked"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.stream_processing__418263",
   "topic": "data_pipelines",
   "subSkill": "stream_processing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dev defines a Kafka Streams session window with an inactivity gap of 5 minutes, expecting two events 4 minutes apart from the same key to merge into one session. Events arrive: t=0 then t=4min on key=A. They observe two separate session-window records emitted, not one merged window. What is the most likely cause?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Two events with identical keys within a 5-minute gap always create separate sessions unless suppress() is called with Suppressed.untilTimeLimit set high."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The first session emitted at its tentative close, then merging happened on a later record but the downstream consumer saw both interim and merged session records."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Session windowing only merges sessions when the upstream input topic is co-partitioned and co-located with the state store on the same broker."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Session windows in Kafka Streams require an explicit grace.ofMillis(0) parameter to be passed before any merge of overlapping per-key sessions takes effect."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.stream_processing__300147",
   "topic": "data_pipelines",
   "subSkill": "stream_processing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A Kafka Streams app uses an EOS-v2 producer writing to a transactional sink topic. After a forced rebalance, downstream consumers configured with 'isolation.level=read_uncommitted' see duplicate records. What is the explanation?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "EOS-v2 only deduplicates within the producer session, so any rebalance reintroduces duplicates downstream"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Transactional records are emitted twice (once speculatively, once on commit) and both are visible always"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Read-uncommitted consumers bypass the consumer-offset coordination that prevents duplicate fetches reliably"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Read-uncommitted consumers see aborted-transaction records that read-committed clients would skip"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.stream_processing__200358",
   "topic": "data_pipelines",
   "subSkill": "stream_processing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best characterizes Kafka Streams compared to a cluster-mode stream engine?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Embedded SQL engine that compiles queries into vectorized plans over columnar files"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Resource manager that schedules operator tasks across a dedicated long-running worker pool"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Push-based service mesh that ships record envelopes between processes via a gRPC layer"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "JVM library embedded in the application process; scales by adding more application instances"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.stream_processing__200031",
   "topic": "data_pipelines",
   "subSkill": "stream_processing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Given a tumbling window of 10s on event-time, what is the window assigned to event ts=2024-01-01T00:00:09.999?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "stream\n  .keyBy(e -> e.user)\n  .window(TumblingEventTimeWindows.of(Time.seconds(10)))\n  .reduce((a,b) -> merge(a,b));\n// event ts = 2024-01-01T00:00:09.999",
    "label": "stream-processing.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "[00:00:01, 00:00:11)"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "[00:00:00, 00:00:10)"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "[00:00:09, 00:00:19)"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "[00:00:00, 00:00:09]"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.stream_processing__100022",
   "topic": "data_pipelines",
   "subSkill": "stream_processing",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the result schema column name produced by this Spark Structured Streaming aggregation?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "fill_gap",
    "code": {
     "lang": "ts",
     "code": "val q = events.groupBy($\"user\").__GAP_g1__()\nq.printSchema()\n// root\n//  |-- user: string (nullable = true)\n//  |-- ???: long (nullable = false)"
    },
    "gaps": [
     {
      "id": "g1",
      "choices": [
       {
        "id": "c1",
        "label": "count_all"
       },
       {
        "id": "c2",
        "label": "count(1)"
       },
       {
        "id": "c3",
        "label": "count"
       },
       {
        "id": "c4",
        "label": "rowCount"
       }
      ]
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.etl_basics__13419",
   "topic": "data_pipelines",
   "subSkill": "etl_basics",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why add a hash column to ETL records?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "To tell cheaply whether a record has changed since the last extraction"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "To detect a corrupted row, which the loader then quarantines for review"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "To spread the records evenly across partitions when they are written out"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "To give each record a key when the source has no primary key of its own"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.etl_basics__13423",
   "topic": "data_pipelines",
   "subSkill": "etl_basics",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is multi-tenant ETL's primary isolation concern?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Storing all tenant data in a single partition"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Running all tenants simultaneously for efficiency"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Ensuring one tenant's data never appears in another tenant's output"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Using separate ETL tools for each tenant"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.etl_basics__2056407",
   "topic": "data_pipelines",
   "subSkill": "etl_basics",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Given this Airflow backfill command, which task instances actually run for the listed date range?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "$ airflow dags backfill \\\n    --start-date 2024-01-01 \\\n    --end-date 2024-01-03 \\\n    daily_sales_etl",
    "label": "etl-basics.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "One run per logical date in [2024-01-01, 2024-01-03), end-exclusive bound."
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "One run per logical date in [2024-01-01, 2024-01-03], inclusive of both bounds."
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Zero runs because backfill refuses dates earlier than the DAG's start_date."
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "One run only for 2024-01-03 because backfill collapses to last logical date."
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.etl_basics__12409",
   "topic": "data_pipelines",
   "subSkill": "etl_basics",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a watermark in incremental ETL processing?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A marker that tracks the last successfully processed point in the source data"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A marker that flags the rows a previous run rejected so a retry can skip them"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A marker that stamps each loaded row with the identifier of the run that wrote it"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A marker that records which schema version the last extraction was run against"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.etl_basics__13446",
   "topic": "data_pipelines",
   "subSkill": "etl_basics",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the write-audit-publish pattern?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Data is written to production, checked there, then rolled back on a failure"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Data is written twice, to staging and production, and the two are then compared"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Data is written to staging, checked for quality, then published onward"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Data is checked at the source, written to staging, then copied without a check"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.etl_basics__12408",
   "topic": "data_pipelines",
   "subSkill": "etl_basics",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the primary risk of running ETL transforms directly on the source database?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It requires the source database to support SQL only"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It can degrade source system performance and impact production applications"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It automatically deletes source data after transformation"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It prevents the target system from receiving any data"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.etl_basics__284619",
   "topic": "data_pipelines",
   "subSkill": "etl_basics",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dbt incremental model gains a new column upstream. Without intervention the next run errors because the target table lacks the column. Which model config value tells dbt to ALTER the target to add the new column automatically?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "incremental_drift='accept_widening_diff'"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "on_schema_change='append_new_columns'"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "on_schema_change='evolve_columns_inline'"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "schema_evolution_mode='auto_alter_add'"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.etl_basics__935721",
   "topic": "data_pipelines",
   "subSkill": "etl_basics",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A team replaces a Python pandas transform step that ran in the orchestrator's worker pod with a SQL model that runs against the warehouse. After the swap, daily transform runtime drops from ~40 min to ~3 min on the same data. Which trade-off best explains the speedup?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Pushing transforms into the warehouse leverages MPP compute and columnar storage on the data's home"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Worker pods incur container cold-start overhead that dominates the pandas transform runtime"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Python's GIL blocks parallel pandas operations so any non-Python runtime is automatically faster"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Network egress fees from the warehouse to the worker dwarf the actual computation time"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.etl_basics__13411",
   "topic": "data_pipelines",
   "subSkill": "etl_basics",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does checkpointing improve ETL reliability?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "By validating all records before processing"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "By recording progress so failed pipelines resume from the last successful point"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "By scaling compute resources during peak loads"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "By running the pipeline faster through parallelism"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.etl_basics__6090841",
   "topic": "data_pipelines",
   "subSkill": "etl_basics",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Given this Dagster asset that uses a sensor-driven watermark, what does the second tick do if the source has no rows newer than the cursor?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "from dagster import sensor, RunRequest, SkipReason\n\n@sensor(job=ingest_job)\ndef events_watermark(context):\n    last = context.cursor or '1970-01-01'\n    new_max = query_max_ts('events', since=last)\n    if new_max <= last:\n        return SkipReason('no new rows')\n    context.update_cursor(new_max)\n    return RunRequest(run_key=new_max, run_config={'ops':{'ingest':{'config':{'since':last}}}})",
    "label": "etl-basics.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Sensor yields SkipReason; no run is launched and the cursor is unchanged."
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Sensor advances cursor to now() and starts a run with zero asset rows."
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Sensor yields RunRequest anyway; pipeline runs on an empty source batch."
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Sensor raises an exception because cursor without new rows is invalid."
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "event_driven.idempotent_consumers__220102",
   "topic": "event_driven",
   "subSkill": "idempotent_consumers",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the transactional outbox technique used on the producer side of an event-driven pipeline?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Domain state is committed first and the broker performs a synchronous read-back against the canonical write log."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Domain state is sharded by aggregate so the broker can pull the latest revision out of a leader replica directly."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Domain state is journaled to a sidecar volume and a CDC agent diffs the volume against the latest known offset."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Domain state and the outgoing message are written together in one local transaction, then a relay publishes the row."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "event_driven.idempotent_consumers__240101",
   "topic": "event_driven",
   "subSkill": "idempotent_consumers",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes why end-to-end exactly-once semantics is generally treated as an idempotency problem rather than a transport problem?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Network and broker layers can only bound queue depth, so the orchestrator carries the burden of routing replays."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Network and broker layers can only bound packet jitter, so the producer carries the burden of pinning the leader."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Network and broker layers can only bound duplicate count, so the receiver carries the burden of making apply safe."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Network and broker layers can only bound serialisation cost, so the schema registry carries the burden of upcast."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "event_driven.idempotent_consumers__78296",
   "topic": "event_driven",
   "subSkill": "idempotent_consumers",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does making event processing a 'pure function of the event' help with idempotency?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Pure functions are automatically cached by the runtime, preventing duplicate execution"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Pure functions are compiled differently, making them inherently faster and safe to retry"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Pure functions run in isolation and cannot touch shared state, so races cannot happen"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Output that depends on the event alone repeats identically on a second delivery"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "event_driven.idempotent_consumers__78090",
   "topic": "event_driven",
   "subSkill": "idempotent_consumers",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'transactional outbox + idempotent consumer' combination and why is it considered the gold standard for reliable messaging?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The outbox makes publishing atomic with the write, and the consumer absorbs the duplicates"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The combination works with Kafka's exactly-once semantics and applies to no other broker"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The outbox handles ordering while the consumer handles deduplication, so no broker is required"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The producer uses idempotent sends to the broker while the consumer writes acks to its own outbox"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "event_driven.idempotent_consumers__78172",
   "topic": "event_driven",
   "subSkill": "idempotent_consumers",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the difference between 'deduplication' and 'idempotency' in event processing?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Deduplication removes duplicate events from the broker; idempotency prevents duplicate events from being published"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Deduplication detects and discards duplicate events before processing; idempotency ensures that processing the same event multiple times produces the same result. Both achieve the same goal through different mechanisms"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "They are identical concepts: deduplication and idempotency are synonyms"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Deduplication is a producer-side concern; idempotency is a consumer-side concern"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "event_driven.idempotent_consumers__78122",
   "topic": "event_driven",
   "subSkill": "idempotent_consumers",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the relationship between 'at-most-once' delivery and message loss?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "At-most-once delivery causes message duplication, not message loss"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "At-most-once delivery means the broker sends the message once and doesn't retry on failure: simpler but messages can be permanently lost if delivery fails"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "At-most-once delivery guarantees no message loss because each message is delivered exactly one time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Message loss only occurs with at-least-once delivery because retries corrupt the original message"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "event_driven.idempotent_consumers__53211",
   "topic": "event_driven",
   "subSkill": "idempotent_consumers",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does Kafka's idempotent producer work, and what problem does it solve?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The idempotent producer batches the messages into one atomic write per partition it targets"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It requires consumers to acknowledge messages before the producer sends the next one"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A producer ID plus a per-partition sequence number lets the broker discard retried writes"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The idempotent producer deduplicates messages based on a payload content hash"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "event_driven.idempotent_consumers__78114",
   "topic": "event_driven",
   "subSkill": "idempotent_consumers",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'exactly-once semantics' (EOS) in Kafka and what are its limitations?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Kafka EOS guarantees that every message is delivered and processed exactly once across all connected systems including databases and external APIs"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "EOS means Kafka stores exactly one copy of each message, eliminating storage overhead from replicas"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Kafka EOS combines idempotent producers and transactional consumers to ensure each record is processed exactly once within the Kafka ecosystem, but it doesn't extend to external systems (databases, APIs) outside the Kafka transaction boundary"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "EOS prevents consumers from reading the same offset twice by locking offsets at the broker level"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "event_driven.idempotent_consumers__78305",
   "topic": "event_driven",
   "subSkill": "idempotent_consumers",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "In everyday terms, what is an 'idempotent' operation?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "An operation that works once and fails on the attempts that follow it"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "An operation that reverses itself when it is performed too many times"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "One that gives the same result once or many times, like an elevator button"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "An operation that runs faster the second time because the result is cached"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "event_driven.idempotent_consumers__78095",
   "topic": "event_driven",
   "subSkill": "idempotent_consumers",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How can Kafka's consumer offset management lead to duplicate processing, even with at-least-once delivery?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Duplicate processing happens when several consumer groups subscribe to one topic"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Kafka delivers messages exactly once, so duplicate processing cannot happen"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The offset is stored inside the event payload, so it cannot be lost in a crash"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A crash after a batch but before the commit replays it from the last offset"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.soft_delete__69828",
   "topic": "data_modeling",
   "subSkill": "soft_delete",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'status lifecycle' pattern as a more flexible alternative to boolean soft delete?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A flag per state, so a row can sit in more than one state at a time"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A second table per state, with the row moved as its state moves along"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A status column naming the state, so each state gets its own handling"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A timestamp per status change, from which the current state is derived"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.soft_delete__10257",
   "topic": "data_modeling",
   "subSkill": "soft_delete",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "After a soft-delete column has been in production for a year on a high-write table, which cost shows up that wasn't visible in the design review?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Replication lag rises in proportion to the count of rows whose removal marker has been set to non-null"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The optimiser issues an implicit FOR UPDATE on rows still carrying NULL in their removal-marker column"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The planner switches to bitmap scans on every table that carries a removal-marker column, regardless of size"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Every read predicate now carries a deleted_at IS NULL check, and indexes must cover it or lose effectiveness"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.soft_delete__100231",
   "topic": "data_modeling",
   "subSkill": "soft_delete",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the soft delete pattern in a relational schema?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Truncating the table on a fixed schedule and rebuilding only rows still considered active"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Issuing a DELETE statement that also cascades through every related child table by default"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Moving the affected row into a parallel archive table inside a single committed transaction"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Marking a row as removed via a flag or timestamp column, leaving the physical row in the table"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.soft_delete__70175",
   "topic": "data_modeling",
   "subSkill": "soft_delete",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'row-level security' approach to implementing soft delete visibility?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A view per table filters the deleted rows, and the queries read the view"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Policies filter the deleted rows by role, leaving the queries untouched"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The client library rewrites each query, adding the filter as it goes out"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A trigger moves the deleted rows aside, so no filter is needed on read"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.soft_delete__10241",
   "topic": "data_modeling",
   "subSkill": "soft_delete",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Soft-removed rows still occupy the unique-constraint space, so a column like email collides on re-signup. Which schema construct restores uniqueness across only the live rows?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "CREATE UNIQUE INDEX users_email_live_uniq\n  ON users (email)\n  WHERE deleted_at IS NULL;",
    "label": "soft-delete.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A trigger that rewrites duplicates by appending a random suffix to the column whenever inserted"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A partial unique index whose predicate filters out rows that already carry a removal marker"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A deferrable unique constraint that postpones the duplicate check until the transaction commits"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A compound unique constraint that bundles the column together with the row's primary key id"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.soft_delete__70251",
   "topic": "data_modeling",
   "subSkill": "soft_delete",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "When implementing GDPR 'right to erasure' alongside soft delete, what schema pattern reconciles the two requirements?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Replace all PII with anonymized values at soft-delete time and keep the row permanently"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Use database-level encryption with per-user keys, and destroy the key on erasure"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A two-phase approach: soft delete (set deleted_at) immediately, then a scheduled job hard-deletes PII after the retention period"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Store PII in a separate encrypted table that is dropped entirely on erasure request"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.soft_delete__70159",
   "topic": "data_modeling",
   "subSkill": "soft_delete",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "In a system with soft deletes, should you display soft-deleted records to end users?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Yes, show them with a deleted stamp, since hiding rows confuses a user"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "No, purge them on read so the deleted rows leave the table for good"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Yes, show them greyed out so a user can restore what was deleted here"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "No, hide them from ordinary users and show them to admins on request"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.soft_delete__301846",
   "topic": "data_modeling",
   "subSkill": "soft_delete",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Compared with simply tagging rows on the live table, what does a system-versioned temporal table model offer that soft delete does not?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "An exemption from indexing the marker column because the engine maintains a global hidden audit map."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A hard guarantee that referential integrity is preserved across all schema changes and all migrations."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A separate history relation timestamped per change, queryable AS OF a past instant without inline tags."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Automatic anonymization of personal columns whenever a row's validity period ends in the active timeline."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.soft_delete__70108",
   "topic": "data_modeling",
   "subSkill": "soft_delete",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'database view' approach to hiding soft-deleted records?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Views hold the deleted rows apart, so a report can still reach them"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Views are refreshed nightly, which is when the deleted rows disappear"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Views filter the deleted rows out, and the application reads the views"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Views rewrite the query as it runs, adding the filter behind the scenes"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.soft_delete__10214",
   "topic": "data_modeling",
   "subSkill": "soft_delete",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Among the column shapes teams pick to flag logically removed rows, which one is the most widely recommended in current style guides?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A reserved sentinel value packed into the primary key column itself to indicate removal status"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A nullable timestamp column whose value records when the row was marked removed"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A boolean column constrained to NOT NULL DEFAULT false, with the value true meaning removed"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A status code stored in a separate one-row metadata table that the application joins on read"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.migration_strategies__69847",
   "topic": "data_modeling",
   "subSkill": "migration_strategies",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A migration file has an "
      },
      {
       "t": "code",
       "v": "up"
      },
      {
       "t": "text",
       "v": " section and a "
      },
      {
       "t": "code",
       "v": "down"
      },
      {
       "t": "text",
       "v": " section. A deploy applies "
      },
      {
       "t": "code",
       "v": "up"
      },
      {
       "t": "text",
       "v": "; a rollback runs "
      },
      {
       "t": "code",
       "v": "down"
      },
      {
       "t": "text",
       "v": ". Which pair most accurately describes the relationship between them?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "code",
        "v": "up"
       },
       {
        "t": "text",
        "v": " runs only against the production environment; "
       },
       {
        "t": "code",
        "v": "down"
       },
       {
        "t": "text",
        "v": " runs only against development and staging copies of the database for safety"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "code",
        "v": "up"
       },
       {
        "t": "text",
        "v": " is executed by the application on startup; "
       },
       {
        "t": "code",
        "v": "down"
       },
       {
        "t": "text",
        "v": " is executed by the database engine automatically on detecting a failure to start"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "code",
        "v": "up"
       },
       {
        "t": "text",
        "v": " advances the schema to the next version; "
       },
       {
        "t": "code",
        "v": "down"
       },
       {
        "t": "text",
        "v": " is meant to return it to the previous version, though some destructive "
       },
       {
        "t": "code",
        "v": "up"
       },
       {
        "t": "text",
        "v": " steps cannot be perfectly reversed"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "code",
        "v": "up"
       },
       {
        "t": "text",
        "v": " performs structural DDL changes; "
       },
       {
        "t": "code",
        "v": "down"
       },
       {
        "t": "text",
        "v": " performs the data backfills that the structural changes require for correctness on existing rows"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.migration_strategies__10307",
   "topic": "data_modeling",
   "subSkill": "migration_strategies",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A long-running migration locks core tables during peak traffic. Which approach lowers risk?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Increase database resources temporarily to handle the migration faster"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Break the migration into smaller DDL statements executed sequentially"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Online or phased migration minimizing blocking operations"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Schedule the migration during a planned maintenance window with downtime"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.migration_strategies__70209",
   "topic": "data_modeling",
   "subSkill": "migration_strategies",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is Atlas in the context of database schema management?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A declarative schema migration tool that computes diffs between desired and actual database state"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A NoSQL database designed for geographically distributed workloads"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A PostgreSQL extension for multi-tenant row-level security"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A cloud-hosted database monitoring dashboard by HashiCorp"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.migration_strategies__52086",
   "topic": "data_modeling",
   "subSkill": "migration_strategies",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does Neon's GitHub Copilot Migration Specialist agent help with schema migrations?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It monitors migration execution and automatically retries failed operations"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It converts Prisma schema files into raw SQL migration scripts"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It automatically generates rollback migrations for every forward migration"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It enables testing schema changes in isolated database branches before applying them to production with zero downtime"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.migration_strategies__70072",
   "topic": "data_modeling",
   "subSkill": "migration_strategies",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is 'migration testing' using a shadow or test database?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Run the migrations twice on production, comparing the two outcomes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Run the migrations inside a transaction that is rolled back at the end"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Run the statements past a linter that flags the risky patterns in them"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Run the migrations against a copy of the production schema first"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.migration_strategies__70150",
   "topic": "data_modeling",
   "subSkill": "migration_strategies",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'version table approach' for managing backwards-incompatible schema changes across microservices?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Keep both table versions live, with a layer for old and new consumers"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Keep a translation service in front, which rewrites the shape per caller"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Keep the old table as a view over the new one, so the readers see both"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Keep one table and a version column, which each consumer filters on"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.migration_strategies__69861",
   "topic": "data_modeling",
   "subSkill": "migration_strategies",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'ghost table' migration technique used by tools like gh-ost?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Change the table in place while the writes are paused for a short window"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Add the new columns beside the old, then drop the old once the code moves"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Copy the table into a new shape, keep it in step, then swap the names"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Copy the table into a new shape and have the readers query both for a while"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.migration_strategies__69892",
   "topic": "data_modeling",
   "subSkill": "migration_strategies",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a 'baseline' migration in Flyway?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It writes the whole current schema as one migration a fresh database runs"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It re-runs the history against a fresh database to confirm they still match here"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It marks the current state as the starting point, so history is not replayed"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It records a checksum per applied migration so a later edit is caught here"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.migration_strategies__100401",
   "topic": "data_modeling",
   "subSkill": "migration_strategies",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A junior runs this against an empty Postgres database. What does psql print after the second statement?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "CREATE TABLE users (id serial PRIMARY KEY);\nALTER TABLE users ADD COLUMN email text;",
    "label": "migration-strategies.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "TABLE UPDATED"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "ALTER COLUMN"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "COLUMN ADDED"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "ALTER TABLE"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.migration_strategies__69856",
   "topic": "data_modeling",
   "subSkill": "migration_strategies",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why should you avoid long-running transactions in database migrations?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "They cause the migration tool to time out and corrupt the schema"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "They prevent the database from accepting new connections"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "They hold locks that block other queries, potentially causing application downtime"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "They consume too much disk space for the transaction log"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_quality__51251",
   "topic": "data_pipelines",
   "subSkill": "data_quality",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the tension between privacy and data quality?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The privacy rules forbid keeping the raw data, so a check has to run before the load"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The privacy techniques cut the ability to validate and correct single records"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The privacy techniques add latency, so the checks cannot run inside the load window"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The privacy rules demand the data be encrypted, which most check tooling cannot read"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_quality__30736",
   "topic": "data_pipelines",
   "subSkill": "data_quality",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does data completeness mean?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Records match their source system byte for byte"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Records arrived within the freshness window set"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Records passed each validation rule defined"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "All expected records and fields are present"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_quality__51249",
   "topic": "data_pipelines",
   "subSkill": "data_quality",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is quality's challenge in multi-model database environments?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The models carry different quality semantics, so one measure across them is hard"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The models lack a schema, so the checks have to infer the shape from the data"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The models are stored apart, so a check cannot join across two of them at once"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The models change shape frequently, so a quality rule written today is stale within a week"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_quality__51238",
   "topic": "data_pipelines",
   "subSkill": "data_quality",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is an organizational quality scorecard's purpose?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A record of each incident and its cause, kept so the pattern can be studied later"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A per-table list of the failing checks, for the engineer on call to work through"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A high-level view of health per domain, for deciding where to invest"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A ranking of the teams by their failure rate, published to encourage improvement"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_quality__3084112",
   "topic": "data_pipelines",
   "subSkill": "data_quality",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Given the model has a duplicate order_id row, what happens when this dbt test runs?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "version: 2\nmodels:\n  - name: stg_orders\n    columns:\n      - name: order_id\n        tests:\n          - unique\n          - not_null",
    "label": "data-quality.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "model rebuilds and removes duplicate"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "test fails with 1 failing record"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "test errors with a compilation issue"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "test passes with a warning emitted"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_quality__51240",
   "topic": "data_pipelines",
   "subSkill": "data_quality",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the challenge of universal quality metrics?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Teams lack the tooling to collect them, so most domains report nothing much"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Teams weight them differently, so the totals cannot be added up across domains"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Teams collect them at different times, so the figures drift apart over a week"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Teams define them differently, so a comparison across domains misleads"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_quality__30734",
   "topic": "data_pipelines",
   "subSkill": "data_quality",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a referential integrity check?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Verifying that a join between two tables returns the same row count on each run"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Verifying every foreign key value exists as a primary key in the referenced table"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Verifying that a column's declared type matches the type the source system had sent"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Verifying that each table's primary key column contains no repeated values in it"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_quality__51239",
   "topic": "data_pipelines",
   "subSkill": "data_quality",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How handle quality for semi-structured JSON logs?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Reject a record whose shape differs from the first one seen, then alert its owner"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Flatten the records into columns first, then apply the checks a table would get"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Infer the schema and validate against it, allowing for optional and nested fields"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Sample the records each hour and compare the field counts against the day before"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_quality__30764",
   "topic": "data_pipelines",
   "subSkill": "data_quality",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is quality's challenge in real-time dashboards?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The checks run per query, so two people can see different figures at one moment"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The checks cannot run on a stream, so a dashboard has to trust what it gets"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The checks add delay, and showing the indicators takes careful design"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The dashboards cache their data, so a correction upstream takes a while to show"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_quality__30767",
   "topic": "data_pipelines",
   "subSkill": "data_quality",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is precision versus accuracy in data quality?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Accuracy is about consistency, precision about closeness to the true value"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Precision applies to numbers and accuracy to text, so the two rarely overlap"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Precision is about consistency, accuracy about closeness to the true value"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Precision counts the decimal places kept, accuracy counts the rows that pass"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_design__70184",
   "topic": "data_modeling",
   "subSkill": "schema_design",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'medallion architecture' (bronze/silver/gold) in modern data platforms?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Three layers, staging then warehouse then mart, each owned by a separate team"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Three layers, cheap then warm then hot storage, moving the data as it ages"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Three copies of the data, one per region, kept in step by a replication stream"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Three layers, raw then cleaned then business-ready, refined at each step"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_design__200342",
   "topic": "data_modeling",
   "subSkill": "schema_design",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "When weighing a narrow normalized table against a wide denormalized one for an order_lines read path, what is the realistic trade-off the wide design accepts?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Update anomalies and storage duplication in exchange for fewer joins"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Loss of NOT NULL enforcement that only narrow tables can keep"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Slower single-row reads because the planner avoids covering indexes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Inability to enforce foreign keys on duplicated values across rows"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_design__70226",
   "topic": "data_modeling",
   "subSkill": "schema_design",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the role of 'effectivity satellites' in Data Vault 2.0?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "They store computed aggregates that are refreshed on a schedule"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "They hold the current snapshot of an entity, replacing all previous satellites"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "They record which ETL job loaded each row for audit purposes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "They track the valid-from and valid-to dates of a relationship in a Link entity"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_design__69769",
   "topic": "data_modeling",
   "subSkill": "schema_design",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the difference between a UUID and an auto-incrementing integer as a primary key?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Auto-incrementing integers are globally unique across all databases"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Auto-incrementing integers cannot be used as primary keys in distributed systems"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "UUIDs are globally unique and can be generated client-side, but are larger and less index-friendly than sequential integers"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "UUIDs are always faster for lookups than integers"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_design__69928",
   "topic": "data_modeling",
   "subSkill": "schema_design",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'polymorphic embeddings' pattern in MongoDB?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Embedding references to documents from multiple collections within a single document"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Creating multiple indexes for different document types in the same collection"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Storing documents of different types in the same collection, using a type field to determine the document structure"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Using MongoDB's $graphLookup to traverse polymorphic relationships"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_design__70017",
   "topic": "data_modeling",
   "subSkill": "schema_design",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is 'hybrid search' in the context of vector store schema design?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Running a keyword search first, then reranking the hits with a small model"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Running the search over a mix of stored and computed columns in one pass"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Running a similarity search alongside a keyword one and blending the results"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Running a similarity search across two indexes and taking the better result here"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_design__69767",
   "topic": "data_modeling",
   "subSkill": "schema_design",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "In a Prisma schema, what does "
      },
      {
       "t": "code",
       "v": "@@map(\"user_accounts\")"
      },
      {
       "t": "text",
       "v": " do on a model?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "model User {\n  id    Int    @id @default(autoincrement())\n  email String @unique\n  @@map(\"user_accounts\")\n}",
    "label": "schema-design.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Enables soft-delete functionality for the model"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Maps the Prisma model name to a different underlying database table name"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Creates a database index on the Prisma model's primary key"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Generates a migration to rename the table"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_design__69968",
   "topic": "data_modeling",
   "subSkill": "schema_design",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'wide column' (column family) data model used by Cassandra and HBase?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Rows keyed for lookup, with dynamic columns grouped into families for sparse writes"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Documents keyed for lookup, with the nested fields indexed as the writes land"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Columns stored separately on disk, so a scan reads the few a query asks about"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Rows keyed for lookup, with a fixed column set declared before the first write here"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_design__20863",
   "topic": "data_modeling",
   "subSkill": "schema_design",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "When designing a table for storing monetary amounts, what data type should be used to avoid rounding errors?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "INTEGER representing amounts in cents, converting to dollars in the application"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "FLOAT or DOUBLE, as these provide the most precision for large numbers"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "TEXT, storing amounts as formatted strings like '$10.99'"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "DECIMAL or NUMERIC with defined precision and scale (e.g., DECIMAL(10,2))"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_design__70217",
   "topic": "data_modeling",
   "subSkill": "schema_design",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What problem does UUIDv7 solve compared to auto-incrementing integer primary keys in distributed systems?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It allows generating globally unique, time-sorted IDs without a central coordinator"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It prevents sequence cache gaps after database crashes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It reduces storage from 8 bytes to 4 bytes per key"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It supports foreign key references across different database engines"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_as_code__8261745",
   "topic": "data_modeling",
   "subSkill": "schema_as_code",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A reverse step is 'DROP TABLE customer_addresses'. The team rolls back a deploy in production after 90 seconds of writes. Engineers report 'all addresses created in that window are gone'. Best mitigation pattern from here?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Wrap the reverse step in a transaction so partial drops can be undone after rollback"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Reorder rollbacks so down steps for table drops run last in the migration sequence"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Treat destructive down steps as unsafe in prod and roll forward with a new migration instead"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Have the deploy tool snapshot every table touched by a migration before the down step"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_as_code__500751",
   "topic": "data_modeling",
   "subSkill": "schema_as_code",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A platform team uses pgroll for expand/contract migrations. They start a migration that adds a NOT NULL column with a backfill, then call "
      },
      {
       "t": "code",
       "v": "pgroll start"
      },
      {
       "t": "text",
       "v": " and immediately try "
      },
      {
       "t": "code",
       "v": "pgroll complete"
      },
      {
       "t": "text",
       "v": " before clients cut over. What is the runtime behaviour?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "// migrations/01_add_required_phone.json\n{\n  \"name\": \"add_required_phone\",\n  \"operations\": [\n    { \"add_column\": {\n        \"table\": \"users\",\n        \"column\": { \"name\": \"phone\", \"type\": \"text\", \"nullable\": false },\n        \"up\": \"'unknown'\"\n    } }\n  ]\n}\n// $ pgroll start migrations/01_add_required_phone.json && pgroll complete",
    "label": "schema-as-code.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "rollback fires automatically after the timeout window"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "new column is enforced for all clients on start"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "old view stays writable until complete is called"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "complete blocks until backfill catches up to the head"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_as_code__400741",
   "topic": "data_modeling",
   "subSkill": "schema_as_code",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A monorepo runs Atlas in versioned mode. The CI step boots a fresh Postgres, applies the file in /migrations, then runs "
      },
      {
       "t": "code",
       "v": "atlas migrate lint --dev-url $DEV_URL --latest 1"
      },
      {
       "t": "text",
       "v": ". The latest file does ALTER TABLE ADD COLUMN with NOT NULL and no DEFAULT. What does lint emit?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "-- migrations/20240501000000_add_required_phone.sql\nALTER TABLE users\n  ADD COLUMN phone text NOT NULL;\n-- $ atlas migrate lint --dev-url $DEV_URL --latest 1",
    "label": "schema-as-code.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "BC102 backward-incompatible column rename diagnostic"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "PG101 missing concurrent index creation diagnostic"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "DS103 destructive column drop diagnostic"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "MF103 data-dependent change (may fail) diagnostic"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_as_code__89034",
   "topic": "data_modeling",
   "subSkill": "schema_as_code",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is 'branded types' in the context of type-safe database IDs?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Tagging each row with the owning team's name so audits can attribute schema changes"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Wrapping every ID in a runtime class instance that validates its format on construction"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Using TypeScript's structural type system to make IDs from different tables incompatible at compile time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Using UUID v5 with a fixed namespace so IDs are deterministic across regenerations"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_as_code__89031",
   "topic": "data_modeling",
   "subSkill": "schema_as_code",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does Convex's schema definition differ from traditional ORM approaches?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "import { defineSchema, defineTable } from 'convex/server';\nimport { v } from 'convex/values';\n\nexport default defineSchema({\n  users: defineTable({\n    name: v.string(),\n    email: v.string(),\n    role: v.union(v.literal('admin'), v.literal('member')),\n  }).index('by_email', ['email']),\n});",
    "label": "schema-as-code.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Convex requires hand-written raw SQL files for schema definitions and applies them through its CLI"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Convex schemas define validators (runtime type checks) that also generate TypeScript types: no SQL, no migrations"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Convex schemas are authored through a hosted web GUI only and exported as static type files on save"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Convex stores JSON Schema documents alongside the database and parses them at every function call"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_as_code__89028",
   "topic": "data_modeling",
   "subSkill": "schema_as_code",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the primary benefit of type-safe database queries?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Compile-time errors when queries reference non-existent columns or use wrong types"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Queries run faster because types are checked at the database level"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Queries are cached more effectively by the database engine"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The database enforces stricter constraints automatically"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_as_code__89036",
   "topic": "data_modeling",
   "subSkill": "schema_as_code",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'expand and contract' pattern for zero-downtime schema migrations?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Deploy code that writes to both old and new columns (expand), migrate data, then remove old column usage (contract)"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Add new tables first (expand), move data with triggers, delete old tables (contract)"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Scale up database replicas before migration, then scale down after completion"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Run migrations in a transaction that expands lock scope, then contracts it on commit"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_as_code__4129836",
   "topic": "data_modeling",
   "subSkill": "schema_as_code",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "CI fails on a PR with: 'Drift detected: column users.legacy_flag exists in the live store but not in your repo files.' The dev swears they did not touch that field. What is this CI check telling them?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The CI database snapshot was restored from a backup taken before the latest deploy"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Someone modified the database directly without writing a corresponding migration file"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A previous migration's down step ran but its up step was never re-executed afterwards"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The seed data script inserted a row that requires a column the schema file omits"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_as_code__100711",
   "topic": "data_modeling",
   "subSkill": "schema_as_code",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A junior runs "
      },
      {
       "t": "code",
       "v": "npx drizzle-kit generate"
      },
      {
       "t": "text",
       "v": " against an empty migrations folder after defining one table in schema.ts. What does the tool emit on disk?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "// schema.ts\nimport { pgTable, serial, text } from 'drizzle-orm/pg-core';\nexport const users = pgTable('users', {\n  id: serial('id').primaryKey(),\n  email: text('email').notNull(),\n});\n// $ npx drizzle-kit generate",
    "label": "schema-as-code.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "a per-table folder of up.sql/down.sql"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "a timestamped .sql file plus meta snapshot"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "an in-memory diff with no file written"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "a single rolling migrations.sql appended"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.schema_as_code__89032",
   "topic": "data_modeling",
   "subSkill": "schema_as_code",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the advantage of colocating schema definitions with application code?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Schema edits no longer require database privileges because they live in the repo"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Schema changes go through the same version control, code review, and CI as the code that uses them"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The database reads its schema from the application code automatically at startup"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Application code runs faster because it can skip schema validation on writes"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_formats__521439",
   "topic": "data_pipelines",
   "subSkill": "data_formats",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A vendor benchmark claims a columnar table beats a transactional table format on point lookups by 4x at the same physical layout. Replays in production show the opposite on a 30-day retention window with hourly upserts: the transactional table is faster at the same hardware. Which structural property of the transactional layer is most likely closing the gap on hot point lookups?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Manifest-level snapshot reuse caches decompressed pages between consecutive lookups on the same key"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Manifest-level metadata pruning skips entire files using partition and column ranges before any data read"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Manifest-level checkpoints maintain per-row offset indexes refreshed by every compaction job tick"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Manifest-level hashing routes lookups through a per-partition hot-cache outside the storage layer"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_formats__30712",
   "topic": "data_pipelines",
   "subSkill": "data_formats",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is Z-ordering in lakehouse table layouts?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Data is clustered along several dimensions, so a filter on either skips files"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Data is sorted on one column, so a filter on that column can skip most of the files"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Data is split by time, so a filter on the timestamp reads a single partition alone"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Data is hashed by key into buckets, so a join on that key needs no shuffle whatever"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_formats__13473",
   "topic": "data_pipelines",
   "subSkill": "data_formats",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why choose a binary format over text for large datasets?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "They can be appended to safely, since a partial write leaves the earlier rows intact"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "They carry the schema alongside the data, so a reader can parse it with nothing else"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "They are more compact and quicker to encode and decode, which cuts the cost of reads"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "They can be inspected by hand, which makes an oddity easier to track down later"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_formats__13492",
   "topic": "data_pipelines",
   "subSkill": "data_formats",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the purpose of bloom filters in Parquet?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "An index that lets the reader jump straight to the row holding a given value"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A quick membership test that lets the reader skip a group without the value"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A checksum that lets the reader detect a group that has been corrupted on disk"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A range test that lets the reader skip a group outside the predicate bounds"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_formats__13484",
   "topic": "data_pipelines",
   "subSkill": "data_formats",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why is Zstandard increasingly preferred over Gzip?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It compresses about as well or better while running considerably faster"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It carries the schema alongside the data, so a reader needs nothing else"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It compresses far better while running at about the same speed as before"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It supports random access inside a block, which the older one cannot do"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_formats__30705",
   "topic": "data_pipelines",
   "subSkill": "data_formats",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the tradeoff of using Zstd at its most aggressive setting for Parquet?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The tradeoff only matters for files over 10 GB"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Higher levels always improve both read and write"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Maximum compression reduces storage but dramatically increases write time"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Zstd level doesn't affect file size"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_formats__13463",
   "topic": "data_pipelines",
   "subSkill": "data_formats",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a delimiter in a CSV file?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The character between field values in a row, a comma as a rule"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The character that ends each row of the file, a newline as a rule"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The character marking a line as a comment to be skipped"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The character that wraps a value holding a separator inside it"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_formats__30701",
   "topic": "data_pipelines",
   "subSkill": "data_formats",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is data skew's impact on Parquet layout performance?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Uneven partitions defeat the statistics, so the planner prunes nothing"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Uneven partitions compress worse, so the storage cost climbs steadily"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Uneven partitions leave stragglers that hold the whole query up"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Uneven partitions exhaust the memory on whichever worker gets the large one"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_formats__13462",
   "topic": "data_pipelines",
   "subSkill": "data_formats",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is Protocol Buffers' advantage over JSON?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Schema evolution the other lacks, since a field can be renamed without a rewrite"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Smaller messages and quicker serialising, from binary encoding and a compiled schema"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Better compression on disk, since the field names are stored once per file rather than per row"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Readable messages and simpler tooling, from a text encoding anyone can inspect"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.data_formats__300009",
   "topic": "data_pipelines",
   "subSkill": "data_formats",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes Arrow IPC compared to Arrow Flight?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "IPC is the on-the-wire serialization for batches while Flight is the gRPC service around it"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "IPC handles point-lookup catalog ops while Flight handles bulk export of Arrow record batches"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "IPC is a Python-only library while Flight is the canonical cross-language Arrow runtime today"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "IPC writes columnar files to disk while Flight is the query planner that consumes those files"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.temporal_data__301817",
   "topic": "data_modeling",
   "subSkill": "temporal_data",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the role of an open-ended sentinel like 9999-12-31 in SCD2?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It marks rows whose primary key was synthesised by the warehouse rather than the source system"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It marks rows that were inserted by backfill jobs rather than by live operational write traffic"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It marks rows scheduled for deletion at the next purge run executed by the retention service"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It marks the still-current revision so simple equality and BETWEEN predicates work without NULL handling"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.temporal_data__69960",
   "topic": "data_modeling",
   "subSkill": "temporal_data",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a simple example of temporal data in everyday applications?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A price history table showing what a product cost at different points in time"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A table storing the current time zone of each user"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A log of database query execution times"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A table storing the latency of network connections"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.temporal_data__69890",
   "topic": "data_modeling",
   "subSkill": "temporal_data",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is an audit trail in the context of data modeling?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A record of who changed what data, when, and what the previous value was"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A list of all users who have read access to a table"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A log of database query performance metrics"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A backup of the database taken at regular intervals"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.temporal_data__10236",
   "topic": "data_modeling",
   "subSkill": "temporal_data",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why is UTC the conventional way to persist event timestamps in geographically distributed systems?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It eliminates the need for per-user locale settings anywhere in the application stack"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It allows the database engine to compress timestamp columns by a larger fixed factor"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It removes ambiguity around daylight-saving transitions and per-region offset drift at storage time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It removes the need for any NTP-style clock synchronisation across application servers"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.temporal_data__70058",
   "topic": "data_modeling",
   "subSkill": "temporal_data",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is SCD Type 0 (retain original)?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The original value is overwritten, and no history is kept for it"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The original value stays put, whatever changes in the real world"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The original value is kept beside a current one in the same row"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The original value moves to a history row as the new one lands"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.temporal_data__200543",
   "topic": "data_modeling",
   "subSkill": "temporal_data",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes EXCLUDE USING gist with tstzrange in PostgreSQL on a history table?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "ALTER TABLE price_history\n  ADD CONSTRAINT no_overlap\n  EXCLUDE USING gist (\n    product_id WITH =,\n    period WITH &&\n  );",
    "label": "temporal-data.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It rejects inserts whose lower bound falls below the table's MIN(start_at) watermark"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It rejects inserts whose period overlaps an existing period for the same business key"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It rejects inserts whose duration exceeds the configured per-table max-span guardrail"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It rejects inserts unless the candidate period sits entirely inside the prior interval"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.temporal_data__10285",
   "topic": "data_modeling",
   "subSkill": "temporal_data",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Historical pricing must be reconstructed for any past date. Which schema element is essential?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Validity interval fields (effective_from/effective_to) on versioned records"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Audit log table capturing all changes as separate event entries"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Timestamp columns recording when each record was created and last updated"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Soft-delete flags preserving historical records without structural changes"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.temporal_data__69789",
   "topic": "data_modeling",
   "subSkill": "temporal_data",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is Slowly Changing Dimension Type 2 (SCD Type 2)?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It keeps history in extra columns, one per attribute that has changed"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It keeps history by adding a row and marking the old one inactive"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It keeps no history, since the value is overwritten where it changes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It keeps history in a side table, the main one holding current values"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.temporal_data__510463",
   "topic": "data_modeling",
   "subSkill": "temporal_data",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the snippet leave in the system-versioned table after the failed UPDATE rolls back?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "BEGIN;\nUPDATE acct\n   SET balance = balance - 50\n WHERE id = 1;\n-- triggers a CHECK constraint failure here\nUPDATE acct\n   SET balance = balance / 0\n WHERE id = 1;\nROLLBACK;",
    "label": "temporal-data.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "one base row updated with the new value despite the rollback boundary"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "one history row plus a base row both rolled forward to the new value"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "one history row written reflecting the failed attempt before the rollback"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "no history row written and the base row unchanged from its prior state"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_modeling.temporal_data__70173",
   "topic": "data_modeling",
   "subSkill": "temporal_data",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the performance implication of SCD Type 2 on large dimension tables?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The table grows a row per attribute change, far past the entity count"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The table grows a column per attribute change, which widens the row here"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The table needs a full rebuild per change, which is what slows the load"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The table stays one row per entity, and the history sits in a side table"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.slowly_changing__200343",
   "topic": "data_warehousing",
   "subSkill": "slowly_changing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Choosing SCD Type 6 over SCD Type 2 for a dimension - what additional capability does the hybrid approach provide?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Type 6 combines hashing with append-only writes, supporting both deduplication and time-travel queries on dimensions"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Type 6 combines versioned rows with a current-value attribute on every row, supporting both as-was and as-is reporting"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Type 6 combines surrogate keys with composite naturals, supporting bitemporal queries and lossless schema evolution"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Type 6 combines an audit table with overwrite semantics, supporting current-state queries plus an external history"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.slowly_changing__53557",
   "topic": "data_warehousing",
   "subSkill": "slowly_changing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the key difference between ETL-based SCD processing and Change Data Capture (CDC)?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "ETL supports only Type 1 SCDs while CDC is required for Types 2, 3, and 4"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "ETL reads from the warehouse while CDC reads from source systems, but both process data in batches"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "CDC requires reloading the entire dimension table on every run while ETL only processes deltas"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "ETL is batch-based and compares full snapshots to detect changes; CDC captures changes in real time by reading database transaction logs as they occur"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.slowly_changing__53762",
   "topic": "data_warehousing",
   "subSkill": "slowly_changing",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What problem does a current_flag or open-ended end_date solve in a Type 2 dimension?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It gives current-state queries a single-predicate hot path so the engine can locate the active version of each entity without scanning every historical row or computing the maximum effective date on the fly per query."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It prevents duplicate business keys across versions by automatically merging any row whose natural-key already exists, ensuring the dimension never holds more than one row per business identity at a time."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It allows fact tables to omit surrogate keys entirely, because joining on the active-flag value is sufficient to retrieve both historical and current attribute readings for any reporting layer."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It stores the immediately prior value of any changed attribute alongside the current value, which is why the same column convention can be reused to implement a Type 3 dimension structure."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.slowly_changing__306259",
   "topic": "data_warehousing",
   "subSkill": "slowly_changing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the canonical placement of dbt snapshots within the staging / intermediate / marts layering?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Run against raw or lightly-cleaned source data so history capture is independent of transformation logic."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Run last in the DAG against published reporting tables to capture user-visible attribute drift."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Run on top of the marts layer to version the final business-facing models for stakeholders."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Run inside the intermediate layer so they can join multiple staging models before snapshotting."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.slowly_changing__308044",
   "topic": "data_warehousing",
   "subSkill": "slowly_changing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A Type 6 row carries current_tier (overwritten Type-1-style), tier (versioned Type-2-style), and previous_tier (Type 3 carry). Customer 42 moves silver → gold. After load, querying the still-active version of customer 42 returns what for these three columns?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "-- new active version row written by load\nINSERT INTO dim_customer\n  (customer_id, tier, current_tier, previous_tier,\n   valid_from, valid_to, is_current)\nVALUES\n  (42, 'gold', 'gold', 'silver',\n   CURRENT_DATE, NULL, TRUE);\n\n-- type-1 overwrite on every prior version\nUPDATE dim_customer\nSET current_tier = 'gold'\nWHERE customer_id = 42 AND is_current = FALSE;",
    "label": "slowly-changing.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "current_tier = gold; tier on this version = gold; previous_tier = gold"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "current_tier = gold; tier on this version = silver; previous_tier = silver"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "current_tier = silver; tier on this version = gold; previous_tier = gold"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "current_tier = gold; tier on this version = gold; previous_tier = silver"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.slowly_changing__305918",
   "topic": "data_warehousing",
   "subSkill": "slowly_changing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes what 'tracked attributes' means on an SCD Type 2 dimension?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The subset of columns automatically masked by access policies to reduce sensitive exposure."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The subset of columns that are projected out of the dimension into downstream reporting marts."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The subset of columns whose changes trigger the insertion of a new versioned row."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The subset of columns enforced by primary-key constraints inside the warehouse engine itself."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.slowly_changing__104901",
   "topic": "data_warehousing",
   "subSkill": "slowly_changing",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "An analyst updates a customer's address in dim_customer with a plain UPDATE statement and is surprised that historical orders now report the new address instead of the address that was on file when the order shipped. Why?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "UPDATE dim_customer\nSET address_line1 = '500 New St'\nWHERE customer_id = 42;",
    "label": "slowly-changing.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Surrogate keys auto-rotate on UPDATE in most modern warehouse engines, which causes the fact-to-dim join to follow the newly rotated key chain backwards through every previously written order row at query-resolution time."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The fact table caches dimension attributes via materialized projections, and the projection rebuild ran before the UPDATE committed, so old orders were re-keyed against the new address row at the storage layer."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Warehouse query planners deduplicate dim joins by natural key during shuffle, which silently collapses the prior address version into the latest one whenever any column on the dim row is touched on a load."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "An in-place UPDATE overwrites the existing dimension row, so every fact joining on that surrogate key now resolves to the rewritten attributes; preserving history requires inserting a new versioned row rather than mutating the row already in place."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.slowly_changing__582931",
   "topic": "data_warehousing",
   "subSkill": "slowly_changing",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dbt project has a snapshot defined for the customers source. After a customer's address changes, the snapshot table now has two rows for that customer_id: one with dbt_valid_to populated and one with dbt_valid_to NULL. Which SCD pattern is dbt snapshots implementing here?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Type 3: a current and previous column pair tracking the most recent prior value"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Type 2: versioned rows tracking each historical state with valid-from / valid-to bounds"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Type 1: overwriting attributes in place without retaining any historical version"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Type 0: freezing the original attribute and rejecting updates after initial load"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.slowly_changing__936208",
   "topic": "data_warehousing",
   "subSkill": "slowly_changing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A snapshot job runs nightly via dbt snapshot. The source table is a transactional Postgres replica where the updated_at column reliably ticks on every row mutation. Which snapshot strategy minimizes warehouse cost and unnecessary version churn?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "check strategy with all columns listed so any drift triggers a new version"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "timestamp strategy with updated_at as the column dbt compares against"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "merge strategy using is_current flag toggled by a post-hook each run"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "incremental strategy with unique_key set to the natural primary key"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.slowly_changing__200344",
   "topic": "data_warehousing",
   "subSkill": "slowly_changing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A team picks SCD Type 1 over SCD Type 2 for a country-code attribute. Which trade-off best justifies that choice?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Reporting only needs current values, and the team accepts losing prior-attribute history to keep the dimension small"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Reporting needs as-was values, and the team accepts a separate history table to retain prior-attribute snapshots"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Reporting needs both states, and the team accepts a previous-value column on every row to track latest change"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Reporting needs full lineage, and the team accepts versioned rows per change to reconstruct attribute timelines"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.batch_processing__51261",
   "topic": "data_pipelines",
   "subSkill": "batch_processing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why is idempotency important in batch jobs?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "An idempotent job runs faster, since the engine can skip the work already done"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "An idempotent job can be retried safely, with no duplicates or wrong results"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "An idempotent job needs no locking, since two copies of it cannot ever conflict"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "An idempotent job can be split across workers, since the order stops mattering"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.batch_processing__441276",
   "topic": "data_pipelines",
   "subSkill": "batch_processing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "dbt 1.8 (2024) decoupled adapter development from dbt-core. What is the effect on the pip install command teams run?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "dbt-core must now be installed as a separate step"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Install dbt-server with a deployment runner"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Install dbt-cloud-cli for any warehouse target"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "None; the adapter package still pulls in dbt-core"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.batch_processing__1013617",
   "topic": "data_pipelines",
   "subSkill": "batch_processing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does this script print as the row count of the full outer join result?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "from pyspark.sql import SparkSession\nspark = SparkSession.builder.getOrCreate()\nleft = spark.createDataFrame([(1,'a'),(2,'b'),(3,'c')], ['k','lv'])\nright = spark.createDataFrame([(1,'x'),(2,'y'),(4,'z')], ['k','rv'])\nj = left.join(right, 'k', 'full_outer')\nprint(j.count())",
    "label": "batch-processing.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "3"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "4"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "6"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "2"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.batch_processing__2018431",
   "topic": "data_pipelines",
   "subSkill": "batch_processing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does a broadcast join in Spark SQL move the join inputs?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Sorts both inputs by the join key and merges sorted streams pairwise inside one executor process"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Writes the smaller side to shared object storage and lets each task page-fault read it on demand"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Sends one small relation in full to every executor so the larger side joins locally without shuffle"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Repartitions both relations on the join key and aligns matching partitions across the cluster nodes"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.batch_processing__915384",
   "topic": "data_pipelines",
   "subSkill": "batch_processing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dev expects a 10 GB Pandas pipeline to scale by simply moving to Spark on a single laptop. The Spark version runs slower than Pandas on the same machine. What did the dev misunderstand?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Spark only enables vectorized execution after the input dataset crosses a fixed 100 GB row threshold"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Spark always runs in local[1] on laptops so it cannot use multiple cores without manual cluster setup"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Spark requires Parquet input to compete with Pandas on small data and was reading CSV"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Spark adds shuffle, serialization and JVM overhead that pays off only at scale or across a cluster"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.batch_processing__5048604",
   "topic": "data_pipelines",
   "subSkill": "batch_processing",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best characterizes the historical Lambda architecture's batch + speed layer split?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Two redundant clusters consume the same source and the slower one is kept idle as warm standby only"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Authoritative recomputation runs over full history while a fast tier serves recent rows in parallel"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A single unified runtime processes every record at ingestion and persists one canonical view downstream"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Source events are routed through a queue and discarded after one consumer acknowledges processing"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.batch_processing__51262",
   "topic": "data_pipelines",
   "subSkill": "batch_processing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is checkpointing's purpose in long-running batch jobs?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Compressing shuffle spill files between stages to cut the disk footprint of long jobs"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Snapshotting metrics at intervals so an operator can chart the job's throughput over time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Caching a dataset in executor memory so repeated actions avoid recomputing it"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Saving state so failed jobs resume from the last checkpoint instead of restarting"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.batch_processing__300454",
   "topic": "data_pipelines",
   "subSkill": "batch_processing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does Spark's "
      },
      {
       "t": "code",
       "v": "repartition(n)"
      },
      {
       "t": "text",
       "v": " behave differently from "
      },
      {
       "t": "code",
       "v": "coalesce(n)"
      },
      {
       "t": "text",
       "v": " when reducing partition count after a wide transformation?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Repartition triggers a full shuffle to balance; coalesce merges existing partitions without shuffling"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Repartition writes results to checkpoint storage; coalesce keeps them as in-memory cached blocks"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Both perform an identical hash shuffle, differing only in whether the result is sorted on disk"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Repartition merges existing partitions without a shuffle; coalesce triggers a full reshuffle balance"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.batch_processing__205333",
   "topic": "data_pipelines",
   "subSkill": "batch_processing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "An ad-hoc SELECT col_a, col_b on a 500 GB CSV table reads the full 500 GB from object storage. The same query on a Parquet copy of the table reads 12 GB. The team asks why Parquet is so much smaller for the same selection. What explains the gap?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Parquet defers row decoding until a filter is added so unfiltered scans read header bytes only"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Parquet keeps an index of distinct values per column letting the engine skip duplicate rows"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Parquet stores data column-wise so only the projected columns are read from object storage"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Parquet pre-aggregates each column block so projection reads precomputed summary rows"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_pipelines.batch_processing__1894591",
   "topic": "data_pipelines",
   "subSkill": "batch_processing",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Running the salted-key skew workaround below against an input where 99% of rows have user_id=42, what does the final agg row count printed at the end equal?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "from pyspark.sql import SparkSession, functions as F\nspark = SparkSession.builder.getOrCreate()\nbase = spark.range(0,1_000_000).selectExpr('CASE WHEN id%100=0 THEN id ELSE 42 END AS user_id','id AS amount')\nsalted = base.withColumn('salt', (F.rand()*10).cast('int'))\npartial = salted.groupBy('user_id','salt').agg(F.sum('amount').alias('s'))\nfinal = partial.groupBy('user_id').agg(F.sum('s').alias('total'))\nprint(final.count())",
    "label": "batch-processing.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "approximately the number of distinct user_id values in the source"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "approximately the total input row count divided by the salt factor"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "approximately the salt cardinality multiplied by partition count fixed"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "approximately ten times the number of distinct user_ids in source"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.modern_warehouse__200150",
   "topic": "data_warehousing",
   "subSkill": "modern_warehouse",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes BigQuery's on-demand pricing model for analytic queries?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It bills by the wall-clock seconds a query takes from submission to completion"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It bills by the count of stages the query plan executes inside the engine"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It bills by the number of bytes a query scans from referenced table columns"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It bills by the byte volume that the final query result delivers to the client"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.modern_warehouse__500412",
   "topic": "data_warehousing",
   "subSkill": "modern_warehouse",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes Snowflake's Hybrid Tables (Unistore) compared with standard FDN tables?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Row-store backed tables that proxy writes to an external operational database via a connector"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Column-store backed tables with primary keys and indexes that bypass the micro-partition layout"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Row-store backed tables with primary keys and indexes that support OLTP-style point operations"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Column-store backed tables that mirror Iceberg metadata into a sibling lakehouse catalog table"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.modern_warehouse__53591",
   "topic": "data_warehousing",
   "subSkill": "modern_warehouse",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Under what conditions should a BigQuery workload move off per-terabyte-scanned billing onto a fixed-fee commitment?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "When you need to run queries across multiple GCP regions simultaneously"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "When you have sporadic, unpredictable query patterns with long idle periods"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "When query volume is high and predictable: slot reservations provide a flat monthly cost and guaranteed compute capacity, which is cheaper than on-demand at scale and critical for SLA-bound workloads"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "When most queries scan less than 1 GB of data and are run interactively"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.modern_warehouse__804156",
   "topic": "data_warehousing",
   "subSkill": "modern_warehouse",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A developer creates a BigQuery materialized view over a partitioned events table and assumes every base-table query will be transparently rewritten to hit the MV. Aggregations against the base table still scan the full partitions. What does the BigQuery documentation say is happening?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Smart tuning is disabled by default on partitioned base tables and must be turned on per-MV via the enable_refresh = true option in the create statement."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Smart tuning is bypassed whenever the base table has streaming inserts in the last 90 minutes, because the MV cannot be considered fresh under that window."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Smart tuning only rewrites a query when the optimizer matches the MV's exact aggregation, grouping keys, and partition filter; otherwise BigQuery falls back to scanning the base table."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Smart tuning is suppressed for any query that selects more than 10 columns, since the rewriter cannot reason about wide projections from an aggregated MV."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.modern_warehouse__200149",
   "topic": "data_warehousing",
   "subSkill": "modern_warehouse",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes Snowflake's multi-cluster warehouse scaling policy?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It resizes the existing warehouse to a larger tier when concurrent queries queue"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It rejects extra concurrent queries above the configured maximum cluster count"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It reroutes queued queries to a sibling warehouse owned by the same role grant"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It adds clusters when concurrent queries queue and removes them as load drops"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.modern_warehouse__100234",
   "topic": "data_warehousing",
   "subSkill": "modern_warehouse",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes BigQuery's columnar storage format Capacitor?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It stores tables in a heap and uses bitmap indexes for predicate pushdown"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It stores rows inside a B-tree keyed on the table's primary key column"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It stores table data row by row to speed up single-record lookups"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It stores table data column by column to speed up analytical scans"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.modern_warehouse__3271944",
   "topic": "data_warehousing",
   "subSkill": "modern_warehouse",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the second query do regarding Snowflake compute on a multi-cluster warehouse with these settings during a load spike?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "-- Snowflake\nALTER WAREHOUSE etl_wh SET\n  MIN_CLUSTER_COUNT = 1\n  MAX_CLUSTER_COUNT = 4\n  SCALING_POLICY = 'STANDARD';\n-- 32 concurrent users hit at 09:00\nSELECT * FROM big_fact LIMIT 10;",
    "label": "modern-warehouse.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Routes the query to the result cache when concurrency saturates"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Resizes the existing cluster to a larger T-shirt size before running"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Spins up an additional cluster to serve the queued query in parallel"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Queues the query indefinitely until the first cluster finishes the batch"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.modern_warehouse__447736",
   "topic": "data_warehousing",
   "subSkill": "modern_warehouse",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Comparing dbt's "
      },
      {
       "t": "code",
       "v": "snapshot"
      },
      {
       "t": "text",
       "v": " against an "
      },
      {
       "t": "code",
       "v": "incremental"
      },
      {
       "t": "text",
       "v": " model with "
      },
      {
       "t": "code",
       "v": "merge"
      },
      {
       "t": "text",
       "v": " for tracking slowly-changing dimension history - what does "
      },
      {
       "t": "code",
       "v": "snapshot"
      },
      {
       "t": "text",
       "v": " give you that "
      },
      {
       "t": "code",
       "v": "incremental"
      },
      {
       "t": "text",
       "v": " does not by default?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "{% snapshot orders_snapshot %}\n{{ config(target_schema='snapshots', unique_key='order_id', strategy='timestamp', updated_at='updated_at') }}\nselect * from {{ source('jaffle_shop', 'orders') }}\n{% endsnapshot %}",
    "label": "modern-warehouse.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Built-in late-arriving fact handling with a SCD-3 column that records the previous attribute value per row"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Built-in SCD-2 valid_from/valid_to columns and dbt-managed change detection per snapshot run"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Built-in column-level masking policies pushed down to the warehouse role at every dbt snapshot run command"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Built-in row-level access predicates derived per source table during compilation of the snapshot file model"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.modern_warehouse__2058393",
   "topic": "data_warehousing",
   "subSkill": "modern_warehouse",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A nightly dbt run accidentally truncated a Snowflake fact table 90 minutes ago. The warning Slack message reads 'rows: 0 (was 412M)'. Storage retention is set to the default for a permanent table. The team needs the rows back without restoring from backup. What recovery feature should they reach for?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Snowflake Time Travel lets them query or restore the table state from before the truncation within the retention window."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Snowflake Fail-safe lets them issue a self-service rewind command to bring the truncated rows back into the same table."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Snowflake Streams replay can re-emit the deleted rows from the change-tracking metadata still attached to the table."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Snowflake Result Cache rehydrates the lost rows because the prior SELECT result is held alongside the table's data."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.modern_warehouse__53590",
   "topic": "data_warehousing",
   "subSkill": "modern_warehouse",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the difference between Snowflake's result cache and the warehouse cache?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The result cache is per-user; the warehouse cache is shared across all Snowflake accounts"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The result cache stores data on disk; the warehouse cache stores data in memory only"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The result cache returns exact previous query results from the Cloud Services layer (free, 24h TTL). The warehouse cache stores raw micro-partition data on local SSD of compute nodes, speeding up subsequent queries that access the same data."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "They are the same cache; 'warehouse cache' is an older name for the result cache"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "caching.cache_invalidation__87116",
   "topic": "caching",
   "subSkill": "cache_invalidation",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Two cache invalidation strategies use the same two steps in opposite sequence: one clears the cached entry first and then writes to the database, the other writes to the database first and then clears the cached entry. Why does the sequence matter?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The ordering of cache deletion and database update affects the window of inconsistency and the risk of stale cache"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It controls whether TTL is applied before or after the cache write"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It refers to the order in which multiple cache nodes are purged"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It determines whether the cache or database is the source of truth"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "caching.cache_invalidation__193845",
   "topic": "caching",
   "subSkill": "cache_invalidation",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes tag-based purge in a caching layer?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Each entry is annotated with labels and a single call removes all entries sharing a label"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Each entry inherits a parent expiry and is rewritten when the parent record is touched"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Each entry is pinned to a shard and dropped when that shard is rebalanced to a peer"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Each entry stores an ETag and the client revalidates by sending it back on the next read"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "caching.cache_invalidation__583129",
   "topic": "caching",
   "subSkill": "cache_invalidation",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes write-through caching with respect to keeping cached data current?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Writes update the cache first and the source is reconciled by a later background job"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Writes only update the source and the cache is refreshed on the next miss path"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Writes go to the cache and the source of truth synchronously before returning"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Writes broadcast an event so any subscriber may decide to refresh its copy"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "caching.cache_invalidation__87050",
   "topic": "caching",
   "subSkill": "cache_invalidation",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is TTL-based cache invalidation?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Using version numbers to mark cache entries as stale"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Invalidating all caches on every write operation"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Setting an expiration time on cache entries so they are automatically removed after a period"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Manually deleting cache entries when notified of changes"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "caching.cache_invalidation__87205",
   "topic": "caching",
   "subSkill": "cache_invalidation",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Your app caches a user's profile for 1 hour. The user changes their name, but the old name shows for up to 59 minutes. What is the core problem?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The CDN is serving a compressed version"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The database write failed silently"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The browser is ignoring the server response"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The cache is not invalidated when the data changes"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "caching.cache_invalidation__217593",
   "topic": "caching",
   "subSkill": "cache_invalidation",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A read-heavy endpoint suffers a stampede every time the cache entry expires. Current cache-pattern guidance suggests probabilistic early expiration (XFetch). What does the technique do to the freshness boundary?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Holds a distributed lock so a single client recomputes after TTL has elapsed"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Recomputes the value before TTL with a probability rising as expiry approaches"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Serves the stale value forever once the first miss converts into a refresh attempt"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Doubles the TTL on every miss until the key reaches a hard ceiling threshold"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "caching.cache_invalidation__87138",
   "topic": "caching",
   "subSkill": "cache_invalidation",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'delayed double deletion' pattern for cache invalidation?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Delete cache, update the DB, then delete the cache again after a short delay"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Wait for two consecutive cache misses before deleting the entry"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Delete the cache entry twice immediately to ensure it's really gone"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Delete from primary and replica caches sequentially"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "caching.cache_invalidation__87156",
   "topic": "caching",
   "subSkill": "cache_invalidation",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is Change Data Capture (CDC) used for in cache invalidation?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Detecting unauthorized changes to cached data"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Capturing user interactions to predict which cache entries to warm"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Streaming database changes to automatically invalidate or update corresponding cache entries"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Compressing change logs to reduce cache storage requirements"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "caching.cache_invalidation__87058",
   "topic": "caching",
   "subSkill": "cache_invalidation",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a cache invalidation race condition?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "When a stale value is written to the cache after the invalidation"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "When TTL expiration and manual invalidation happen at the exact same time"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "When two cache nodes try to invalidate the same key simultaneously"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "When the cache fills up faster than entries can be evicted"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "caching.cache_invalidation__310511",
   "topic": "caching",
   "subSkill": "cache_invalidation",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What integer does the final DBSIZE return?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "SET a 1\nSET b 2\nFLUSHDB ASYNC\nSET c 3\nDBSIZE",
    "label": "cache-invalidation.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "1"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "0"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "2"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "3"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.integration_testing__10185",
   "topic": "testing_strategies",
   "subSkill": "integration_testing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What ongoing cost do integration tests carry that unit tests do not?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Managing real infrastructure lifecycle across startup, seeding, isolation and teardown"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Requiring the test runner to fork worker processes for every individual assertion call"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Producing more line coverage per scenario than an equivalent unit test would yield"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Authoring assertions in a domain-specific language separate from the production code"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.integration_testing__528",
   "topic": "testing_strategies",
   "subSkill": "integration_testing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does 'testing the contract' mean in an integration context?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Checking that both services were built from the same commit of the shared repository"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Checking that every environment variable the two services read is defined"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Checking that the shared client library still compiles against both services"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Checking that two services agree on request shape, status codes, and payload fields"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.integration_testing__10188",
   "topic": "testing_strategies",
   "subSkill": "integration_testing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does 'testing the contract' mean in an integration context?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Verifying services exchange agreed request/response formats and shapes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Ensuring all required environment variables are defined and populated"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Signing a legal agreement between the development team leads and managers"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Checking that the full codebase compiles without any errors or warnings"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.integration_testing__760",
   "topic": "testing_strategies",
   "subSkill": "integration_testing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the benefit of using a separate test configuration for integration tests?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It prevents integration tests from appearing in code coverage"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It isolates database URLs, keys, timeouts, and log levels"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Test configurations make the whole suite run faster"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It is required by all integration test frameworks"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.integration_testing__300523",
   "topic": "testing_strategies",
   "subSkill": "integration_testing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the assertion on the JWT-protected route evaluate to for the two requests below?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "import express from 'express';\nimport request from 'supertest';\nimport jwt from 'jsonwebtoken';\n\nconst app = express();\napp.get('/me', (req, res) => {\n  const h = req.headers.authorization;\n  if (!h) return res.status(401).end();\n  try { jwt.verify(h.replace('Bearer ', ''), 'k'); return res.status(200).json({ ok: 1 }); }\n  catch { return res.status(401).end(); }\n});\n\nconst a = await request(app).get('/me');\nconst b = await request(app).get('/me').set('Authorization', `Bearer ${jwt.sign({ s: 1 }, 'k')}`);\nconsole.log([a.status, b.status]);",
    "label": "integration-testing.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "[401, 200]"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "[401, 403]"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "[403, 200]"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "[401, 204]"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.integration_testing__10186",
   "topic": "testing_strategies",
   "subSkill": "integration_testing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why does deterministic seed data matter for integration tests?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It anchors assertions to a known starting state so test outcomes are reproducible across runs"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It lets the test framework reuse one connection across parallel workers without serialization"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It eliminates the need for the application schema to declare any explicit nullability constraints"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It allows the database to skip statistics collection and execute queries from cached plans alone"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.integration_testing__111024",
   "topic": "testing_strategies",
   "subSkill": "integration_testing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "In CI, an integration test using testcontainers Postgres adds ~8s of startup compared with a mocked repository. How should a team compare these against a jest.mock approach when making a 'keep or drop' decision?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The slower run is never worth it; mocks cover every migration and constraint violation bug in realistic projects."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Both paths catch identical bug classes; the sole tradeoff is CI minutes billed and developer local iteration speed."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The mocked path is strictly more realistic because mocks by design reflect the current database schema exactly."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The slower run is often worth it because real-DB tests catch migration and constraint bugs mocks cannot model."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.integration_testing__10196",
   "topic": "testing_strategies",
   "subSkill": "integration_testing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the practical tradeoff of using transaction rollback as the cleanup strategy?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Cleanup is essentially free, but write-heavy scenarios are forced to run against a read replica instance"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Cleanup is essentially free, but code paths that open their own transactions get harder to test"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Cleanup is essentially free, but per-scenario data must be inserted via a separate connection pool member"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Cleanup is essentially free, but the database server must be configured with autocommit disabled globally"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.integration_testing__750",
   "topic": "testing_strategies",
   "subSkill": "integration_testing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why might an integration test pass locally but fail in CI?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Integration suites are skipped by default until a flag turns them on in the CI job"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "CI runners install a different assertion library than the one the local test setup uses"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The CI environment differs in database version, open ports, or environment variables"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Local machines execute the same suite faster, so timeouts never fire there"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.integration_testing__10108",
   "topic": "testing_strategies",
   "subSkill": "integration_testing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which authoring habit most commonly turns a green integration suite flaky over time?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Letting earlier scenarios mutate database state that later scenarios depend on implicitly"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Running the suite serially when the worker count exceeds the available DB connection pool"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Pinning the testcontainers image to a specific minor version across the entire repository"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Wrapping each scenario in its own transaction that rolls back at teardown without committing"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.mutation_testing__135482",
   "topic": "testing_strategies",
   "subSkill": "mutation_testing",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Stryker applies the AssignmentOperator mutator, swapping += for -=. What does the reducer log after one loop pass?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "let acc = 0;\nfor (const n of [1, 2, 3]) {\n  acc -= n; // mutated from: acc += n\n}\nconsole.log(`acc: ${acc}`);",
    "label": "mutation-testing.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "acc: 6"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "acc: 0"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "acc: -6"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "acc: NaN"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.mutation_testing__629",
   "topic": "testing_strategies",
   "subSkill": "mutation_testing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a 'mutant' in mutation testing?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A test rewritten to assert against a deliberately different expected value"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A duplicated copy of the test file marked .only to bypass the rest of the suite"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A copy of the source containing one deliberate change, such as flipping > to >="
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A function decorated to throw at runtime so callers exercise the catch path"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.mutation_testing__635",
   "topic": "testing_strategies",
   "subSkill": "mutation_testing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why is mutation testing computationally expensive?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Each mutant compiles against a freshly made sandbox image to keep its workspace isolated"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Each mutant queues behind the slowest spec because workers cannot run in parallel"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Each mutant re-runs the affected tests, so cost scales with mutants times covering tests"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Each mutant runs through a static analyzer before the suite executes against it"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.mutation_testing__300024",
   "topic": "testing_strategies",
   "subSkill": "mutation_testing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the purpose of the Stryker Dashboard for a team running mutation testing?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Compile mutants on a remote worker pool to offload cost from the local CI runner"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Serve a coverage cache so consecutive incremental runs can reuse prior hash data"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Publish mutation reports to a shared site so the team can track score over time"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Host a registry of published mutator plugins that teams can install on demand"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.mutation_testing__936728",
   "topic": "testing_strategies",
   "subSkill": "mutation_testing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A team inherits a service with mutation score 94%. On-call sees three production incidents in two weeks tied to regressions in request parsing. Which Kent-flavored explanation fits the signals?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Parsing code cannot be mutated, so the 94% score excluded it from the calculation entirely"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Scores above 90% always correlate with zero production regressions in any service"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A high score guarantees safety, so the incidents must have a root cause outside code"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The suite over-tests pure logic while integration boundaries lack realistic scenarios"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.mutation_testing__10100",
   "topic": "testing_strategies",
   "subSkill": "mutation_testing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "In mutation testing, what does a high mutation score indicate?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Most planted faults produce identical runtime outputs"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Most planted faults cause at least one test to fail"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Most assertions completed within the configured budget"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Most of the production lines were executed during the run"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.mutation_testing__1902736",
   "topic": "testing_strategies",
   "subSkill": "mutation_testing",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dev runs a mutation pass with "
      },
      {
       "t": "code",
       "v": "coverageAnalysis: 'perTest'"
      },
      {
       "t": "text",
       "v": " against a suite using "
      },
      {
       "t": "code",
       "v": "jest.useFakeTimers()"
      },
      {
       "t": "text",
       "v": ". Mutants survive that should have been killed by timer-dependent assertions. What is the root cause?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Fake timers change the observed execution graph so coverage data collected on originals does not match the mutant's real dependencies"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Fake timers disable per-test coverage instrumentation in Jest, so the instrumentation emits empty coverage for those tests"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Fake timers stub out Date.now at the runtime layer, which makes each worker's own internal timeout heuristics misclassify every mutant"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Fake timers are incompatible with worker parallelism, causing one worker to poison the clock for all other worker processes"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.mutation_testing__811",
   "topic": "testing_strategies",
   "subSkill": "mutation_testing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does a mutation testing report typically show?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Per-file counts of executed lines, executed branches, and unreached statements only"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Per-file counts of killed, survived, timed-out, and no-coverage mutants plus a score"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Per-file counts of compile errors, lint warnings, and TypeScript inference failures"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Per-file counts of test files imported, test cases declared, and assertions executed"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.mutation_testing__937204",
   "topic": "testing_strategies",
   "subSkill": "mutation_testing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A team wires Stryker into CI and sees mutant runs exceed the job budget. Modern Stryker guidance suggests which first remediation?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Enable incremental mode plus a changed-files filter scoped to the PR diff"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Switch the runner to a single worker so warm caches stay hot across mutants"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Disable the StringLiteral and ConditionalExpression operators project-wide"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Relax the timeout multiplier until almost no mutant is flagged as TimedOut"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "testing_strategies.mutation_testing__400033",
   "topic": "testing_strategies",
   "subSkill": "mutation_testing",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How do surviving and equivalent mutant outcomes differ?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Survivors leave observable output unchanged; equivalents expose a suite gap"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Survivors require manual review by a developer; equivalents are automatically discarded"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Survivors fail to compile against the project; equivalents fail against the runner"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Survivors expose a suite gap; equivalents leave observable output unchanged"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "analytics.dashboards__30805",
   "topic": "analytics",
   "subSkill": "dashboards",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A data team creates a dashboard with 25 metrics across 5 charts. Stakeholders stop using it after 2 weeks. What is the most likely cause and remediation?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Dashboard overload: 25 metrics require too much cognitive effort to synthesize; the fix is to identify the 3-5 most decision-relevant metrics and restructure the dashboard around actionable signals with context"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Stakeholders are not data-literate; remediation requires a company-wide analytics training program before dashboard adoption can succeed"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The dashboard queries are too slow (loading in 15+ seconds); performance optimization will restore stakeholder engagement"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "25 metrics is within normal range for business dashboards; the low usage indicates the dashboard is correctly showing healthy stable metrics that require no action"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "analytics.dashboards__200576",
   "topic": "analytics",
   "subSkill": "dashboards",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes Apache Superset as a BI tool?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A proprietary cloud service offered by Apache Software Foundation that bundles a managed warehouse and dashboard editor"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A streaming visualization engine restricted to Kafka topics that cannot connect to traditional relational data warehouses"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A command-line analytics framework that requires Python scripts to declare every chart and refuses to run any UI"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "An open-source web app that connects to many SQL databases and lets users build datasets, charts, and dashboards via a UI"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "analytics.dashboards__400562",
   "topic": "analytics",
   "subSkill": "dashboards",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does Cube return for each row of this trailing-7-day rolling-window measure when the source has value=10 per day and at least 7 days of history precede every queried row?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "cube('Sessions', {\n  sql: 'SELECT * FROM sessions',\n  measures: {\n    seven_day: { type: 'sum', sql: 'value',\n                 rollingWindow: { trailing: '7 day', offset: 'end' } }\n  },\n  dimensions: { date: { sql: 'd', type: 'time' } }\n});\n// source: value=10 each day, with >=7 days of history before every queried row (full windows)",
    "label": "dashboards.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Each row equals 70"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Each row equals 210"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Each row equals 300"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Each row equals 10"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "analytics.dashboards__200501",
   "topic": "analytics",
   "subSkill": "dashboards",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does CUPED-adjusted variance differ from naive sample variance when a dashboard reports experiment lift CIs?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "CUPED reduces variance via a pre-period covariate; naive variance ignores the pre-period and stays wider"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "CUPED inflates variance by adding a Bayesian prior; naive variance shrinks by a Bonferroni correction term"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "CUPED requires a holdout arm to be assigned daily; naive variance requires triple-arm assignment per user"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "CUPED applies only on count metrics with denominators; naive variance applies only on ratio rate metrics now"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "analytics.dashboards__30798",
   "topic": "analytics",
   "subSkill": "dashboards",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dashboard shows total revenue by month as a bar chart. A stakeholder asks to add 'revenue by customer segment' to the same chart. What is the best visualization approach?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Use a stacked bar chart (to show both total and segment breakdown simultaneously) or side-by-side grouped bars (to compare segment sizes directly), depending on whether relative composition or absolute comparison is more important"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Create a separate chart for each segment rather than combining them, to avoid overcomplicating a single visualization"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Replace the bar chart with a pie chart showing segment percentages, then add the revenue total as a text annotation"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Add a second Y-axis with segment revenue plotted as a line chart on top of the existing bars"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "analytics.dashboards__402713",
   "topic": "analytics",
   "subSkill": "dashboards",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the role of an SRM (sample ratio mismatch) tile on an experimentation dashboard?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It calculates the lift of the treatment over the control using a post-hoc Bayesian model that updates after every batch of new exposures"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It draws a forest plot of segment-level lifts so the analyst can decide which subgroup deserves a follow-up power calculation later"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It compares observed assignment counts to the planned split and flags significant deviation as evidence of a logging or randomization defect"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It reports the time to statistical significance so analysts can choose to ship the variant earlier than the prereg horizon allows"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "analytics.dashboards__17010",
   "topic": "analytics",
   "subSkill": "dashboards",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Two weekly-review dashboards show the same KPIs. One lets readers reach conclusions faster. Which design choice most plausibly explains the speed difference?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Tiles are sorted alphabetically by metric name so readers can locate any KPI quickly"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Each tile is rendered at a larger font size so the headline numbers are easier to read"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Tiles refresh at a higher cadence so the displayed numbers are closer to real time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Each tile shows the value next to its target and prior-period delta, not the raw number alone"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "analytics.dashboards__500317",
   "topic": "analytics",
   "subSkill": "dashboards",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Two LookML measures compute revenue per user, one direct and one derived. What does Looker emit when both are placed on the same tile and the explore joins users 1->N to orders?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "view: orders {\n  measure: rev_per_user_a {\n    type: number\n    sql: SUM(${TABLE}.amount) / NULLIF(COUNT(DISTINCT ${users.id}),0) ;;\n  }\n  measure: rev_per_user_b {\n    type: number\n    sql: ${total_amount} / NULLIF(${users.count},0) ;;\n  }\n}\n# tile selects both; explore joins users 1->N orders",
    "label": "dashboards.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Errors on duplicate measure name"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Single column with derived alias"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Two distinct SQL expressions"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "One shared SQL via dedup CTE"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "analytics.dashboards__100235",
   "topic": "analytics",
   "subSkill": "dashboards",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A self-serve Hex dashboard shows wildly different DAU values per analyst - each saved a personal 'DAU' query. Engineering wants one canonical number. What is the right structural fix?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Add a comment block to each dashboard tile explaining the analyst's own filter"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Lock down dashboard editing rights to a single analyst on the data team"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Pre-aggregate raw events into a daily snapshot table that anyone can query"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Move the metric definition into a semantic layer all dashboards must consume"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "analytics.dashboards__52159",
   "topic": "analytics",
   "subSkill": "dashboards",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does ThoughtSpot's SpotterViz agent automate in the dashboard creation workflow?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It translates existing Tableau dashboards into ThoughtSpot format through automated schema mapping"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It optimizes dashboard rendering performance by automatically caching the most frequently viewed charts"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It plans the data story, generates answers from queries, and builds complete Liveboards automatically from natural-language prompts"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It applies brand-compliant color schemes and typography to all visualizations based on uploaded style guides"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.data_governance__733951",
   "topic": "data_warehousing",
   "subSkill": "data_governance",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Snowflake's classification feature evolved recently. What is the current documented behavior for assigning the SEMANTIC_CATEGORY system tag to columns Snowflake has classified?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A classification profile created with auto_tag enabled applies system tags after classification"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "EXTRACT_SEMANTIC_CATEGORIES followed by manual ALTER COLUMN SET TAG calls per identified column"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "EXTRACT_SEMANTIC_CATEGORIES followed by ASSOCIATE_SEMANTIC_CATEGORY_TAGS auto-applies system tags"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "AUTOCLASSIFY_SCHEMA scheduled task that scans new tables and writes results into INFORMATION_SCHEMA"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.data_governance__2042918",
   "topic": "data_warehousing",
   "subSkill": "data_governance",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the correct characterization of a data contract between a producer and a consumer?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "An IAM policy attached to the producer service that lets it write into the consumer-owned object storage bucket."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A scheduling agreement that pins the producer build to run before the consumer build inside the orchestrator DAG."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "An execution plan that the warehouse caches between producer and consumer to avoid redundant recomputation."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "An agreed schema and set of guarantees that the producer commits to upholding for downstream consumers."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.data_governance__63048292",
   "topic": "data_warehousing",
   "subSkill": "data_governance",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dbt project enforces contracts via the "
      },
      {
       "t": "code",
       "v": "dbt_contract_check"
      },
      {
       "t": "text",
       "v": " macro below. The downstream model adds a new column not declared. What does CI emit?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "# schema.yml\nmodels:\n  - name: dim_user\n    config:\n      contract:\n        enforced: true\n    columns:\n      - name: user_id\n        data_type: integer\n      - name: created_at\n        data_type: timestamp\n\n-- dim_user.sql\nselect\n  user_id,\n  created_at,\n  signup_source -- new, not in contract\nfrom {{ ref('stg_users') }}",
    "label": "data-governance.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Tests pass column added optional"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Schema breaking change detected fail"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Warning logged contract drift only"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Successful build new column included"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.data_governance__200433",
   "topic": "data_warehousing",
   "subSkill": "data_governance",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A GDPR erasure request lands. The user's row is deleted from the warehouse fact table, but the same identifier still appears in last week's nightly snapshot table and in Time Travel queries. What is the proximate reason the data is still reachable?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Snapshot tables and Time Travel retain only schema metadata across the live delete"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Snapshot tables and Time Travel retain only foreign-key references on the live delete"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Snapshot tables and Time Travel retain only column tags inherited from the live delete"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Snapshot tables and Time Travel retain historical rows independently of the live delete"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.data_governance__74057314",
   "topic": "data_warehousing",
   "subSkill": "data_governance",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A content:inspect call requests the EMAIL_ADDRESS infoType with minLikelihood LIKELY. Where does a match appear in the response?"
      }
     ]
    }
   ],
   "code": {
    "lang": "sql",
    "code": "POST https://dlp.googleapis.com/v2/projects/p/content:inspect\n{\n  \"item\": {\"value\": \"contact: alice@acme.io\"},\n  \"inspectConfig\": {\n    \"infoTypes\": [{\"name\": \"EMAIL_ADDRESS\"}],\n    \"minLikelihood\": \"LIKELY\",\n    \"includeQuote\": true\n  }\n}",
    "label": "data-governance.sql"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Under overview.transformedBytes, as a per-type byte tally"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Under result.infoTypeStats[], as a per-type count for the request"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Under result.findings[], as a Finding with its type"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Under result.findingsTruncated, as a flag holding the matched quote"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.data_governance__400563",
   "topic": "data_warehousing",
   "subSkill": "data_governance",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Comparing OpenLineage's column-level facet against vendor-only column lineage from a single catalog, which strategic property does OpenLineage protect?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Automatic translation of the source system's native masking policies into equivalent governance rules at the destination"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Lineage portability across orchestrators and warehouses, since the spec-defined event format is producer-agnostic"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Sub-millisecond latency between job completion and the lineage graph rendering inside the catalog's primary user interface"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Built-in storage of the full row-level dataset alongside lineage so consumers can replay every transformation in place"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.data_governance__5034186",
   "topic": "data_warehousing",
   "subSkill": "data_governance",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the correct characterization of k-anonymity as a re-identification control on released datasets?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Each released record is split across k separate shards so reconstruction requires colluding shard custodians."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Each released record is signed by k independent attestors before any downstream consumer is allowed to ingest."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Each released record is indistinguishable from at least k minus one other records on the quasi-identifier set."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Each released record is encrypted under a unique key and decrypts only inside an attested confidential enclave."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.data_governance__53714",
   "topic": "data_warehousing",
   "subSkill": "data_governance",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a data mesh approach to governance and how does it differ from centralized governance?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Data mesh is a technical architecture for distributing data across microservices with no governance implications"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Data mesh centralizes all data into a single warehouse managed by a platform team"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Data mesh eliminates the need for governance entirely by making each team fully autonomous"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Data mesh decentralizes data ownership to domain teams (each team owns their data products), but federates governance policies (interoperability standards, quality SLAs, security baselines) centrally. This differs from centralized governance where a single team owns all data and all policies."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.data_governance__4012568",
   "topic": "data_warehousing",
   "subSkill": "data_governance",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes attribute-based access control compared to role-based access control?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Decisions are evaluated against the cost of the proposed query plan and reject anything above a configured spend cap."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Decisions are evaluated against the network origin of the request and applied uniformly across all warehouse principals."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Decisions are evaluated against attributes of the subject, resource, and context, not solely against assigned roles."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Decisions are evaluated against the freshness of the underlying dataset and gate access until ingestion has completed."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "data_warehousing.data_governance__400565",
   "topic": "data_warehousing",
   "subSkill": "data_governance",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Comparing a centralised consent-store join at query time against propagating consent flags into every fact table, which downside hits the centralised join hardest?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Backfilling historical consent decisions becomes impossible because the central store rejects writes for any prior calendar date"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "BI tools refuse to render a query that performs a join against more than one governance-tagged table during dashboard load"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The store cannot be replicated across regions due to GDPR data-residency rules that ban any cross-border consent reference data"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Every analytical query takes a join hit and a stale read risk against the consent store on each execution path"
       }
      ],
      "shape": "long"
     }
    ]
   }
  }
 ]
}