restore.diff

diff --git a/src/pages/AWSExam.jsx b/src/pages/AWSExam.jsx
index cfb7b86..eb9e548 100644
--- a/src/pages/AWSExam.jsx
+++ b/src/pages/AWSExam.jsx
@@ -1,1884 +1,1998 @@
-import { useState, useEffect } from 'react'
-import { useParams, useLocation, useNavigate } from 'react-router-dom'
-import { useAuth } from '../contexts/AuthContext'
-import {
-  doc,
-  getDoc,
-  setDoc,
-  updateDoc,
-  collection,
-  addDoc,
-  serverTimestamp,
-  increment,
-  query,
-  where,
-  getDocs
-} from 'firebase/firestore'
-import { db } from '../config/firebase'
-import {
-  Clock, Flag, ChevronLeft, ChevronRight, Check, X,
-  AlertCircle, CheckCircle, ArrowLeft, Cloud
-} from 'lucide-react'
-import { updateStreak } from '../services/learningService'
-import { DEA_C01_PRACTICE_QUESTIONS } from '../data/deaC01PracticeQuestions'
-import { DEA_C01_PAPER_2_QUESTIONS } from '../data/deaC01Paper2Questions'
-import { DEA_C01_PAPER_3_QUESTIONS } from '../data/deaC01Paper3Questions'
-import { DEA_C01_PAPER_6_QUESTIONS } from '../data/deaC01Paper6Questions'
-import { DEA_C01_PAPER_4_QUESTIONS } from '../data/deaC01Paper4Questions'
-import { DEA_C01_PAPER_5_QUESTIONS } from '../data/deaC01Paper5Questions'
-import { DEA_C01_PAPER_8_QUESTIONS } from '../data/deaC01Paper8Questions'
-
-// AWS DEA-C01 Question Bank - 69 Scenario-Based Questions (matches real exam)
-const AWS_QUESTIONS = {
-  // Domain 1: Data Ingestion and Transformation (34% - 24 questions)
-  1: [
-    {
-      id: 'd1_1',
-      question: "A company needs to ingest streaming data from IoT sensors and store it in Amazon S3 with near real-time delivery. The data should be automatically converted to Parquet format. Which solution meets these requirements with the LEAST operational overhead?",
-      options: [
-        "Use Amazon Kinesis Data Streams with AWS Lambda to convert and write to S3",
-        "Use Amazon Kinesis Data Firehose with record format conversion enabled",
-        "Use Amazon MSK (Managed Streaming for Kafka) with Kafka Connect to S3",
-        "Use AWS Glue Streaming ETL job to process and write to S3"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Amazon Kinesis Data Firehose provides the LEAST operational overhead as it's a fully managed service that can automatically convert data formats (including to Parquet) and deliver to S3. It requires no code and handles scaling automatically.",
-      domain: 1,
-      topic: "Streaming Ingestion",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_2',
-      question: "A data engineer needs to extract data from an on-premises Oracle database and load it into Amazon Redshift. The initial load is 10 TB and ongoing changes must be captured continuously. Which approach is MOST efficient?",
-      options: [
-        "Use AWS Database Migration Service (DMS) with full load and CDC",
-        "Export data to CSV files, upload to S3, and use COPY command",
-        "Use AWS Glue JDBC connection for initial and incremental loads",
-        "Use Amazon AppFlow to connect Oracle and Redshift"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "AWS DMS with full load and Change Data Capture (CDC) is the most efficient solution. It handles the initial bulk load and then captures ongoing changes from the Oracle redo logs, providing continuous replication to Redshift.",
-      domain: 1,
-      topic: "Database Migration",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_3',
-      question: "A company uses AWS Glue for ETL jobs. The jobs are failing because of schema changes in the source data. What should the data engineer implement to handle schema evolution? (Select TWO)",
-      options: [
-        "Enable the AWS Glue Schema Registry",
-        "Use DynamicFrame instead of DataFrame in the Glue job",
-        "Increase the memory allocation for the Glue job",
-        "Configure the Glue crawler to update table schema on each run",
-        "Use Amazon Athena instead of AWS Glue"
-      ],
-      correctAnswer: null,
-      correctAnswers: [1, 3],
-      type: "multiple",
-      selectCount: 2,
-      explanation: "DynamicFrame in AWS Glue can handle schema inconsistencies through features like 'choice' type handling. Configuring the Glue crawler to update the schema ensures the Data Catalog reflects the latest source schema.",
-      domain: 1,
-      topic: "Schema Evolution",
-      difficulty: "hard"
-    },
-    {
-      id: 'd1_4',
-      question: "An AWS Glue ETL job processes 500 GB of JSON files daily. The job is taking 4 hours to complete. Which optimization will MOST likely reduce the job duration?",
-      options: [
-        "Increase the number of DPUs (Data Processing Units)",
-        "Convert source files to Parquet format before processing",
-        "Use AWS Glue bookmarks to process only new data",
-        "Switch from Python to Scala for the ETL script"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Converting JSON to Parquet before processing will significantly improve performance. Parquet is columnar, compressed, and supports predicate pushdown. Reading 500 GB of JSON is much slower than reading optimized Parquet files.",
-      domain: 1,
-      topic: "Performance Optimization",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_5',
-      question: "A real-time analytics application requires sub-second latency for data ingestion. The data comes from mobile applications at a rate of 100,000 events per second during peak hours. Which architecture should be used?",
-      options: [
-        "Amazon Kinesis Data Firehose  Amazon S3  Amazon Athena",
-        "Amazon Kinesis Data Streams  AWS Lambda  Amazon DynamoDB",
-        "Amazon SQS  AWS Lambda  Amazon RDS",
-        "Amazon MSK  Amazon EMR  Amazon Redshift"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "For sub-second latency with 100K events/second, Kinesis Data Streams to Lambda to DynamoDB provides real-time processing. DynamoDB offers single-digit millisecond latency. Firehose has 60-second minimum buffering.",
-      domain: 1,
-      topic: "Real-time Processing",
-      difficulty: "hard"
-    },
-    {
-      id: 'd1_6',
-      question: "A data pipeline uses AWS Step Functions to orchestrate multiple AWS Glue jobs. One job frequently fails due to source system unavailability. How should the data engineer implement resilient error handling?",
-      options: [
-        "Add a Catch block with exponential backoff retry in Step Functions",
-        "Increase the timeout for the Glue job",
-        "Use Amazon EventBridge to schedule retries",
-        "Implement error handling in the Glue job code only"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "Step Functions supports native Retry with exponential backoff and Catch blocks for error handling. This provides resilient orchestration at the workflow level without modifying individual job code.",
-      domain: 1,
-      topic: "Pipeline Orchestration",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_7',
-      question: "A company needs to transform semi-structured JSON data with nested arrays into a flattened relational format for analysis. Which AWS Glue feature should be used?",
-      options: [
-        "Glue Data Quality",
-        "Relationalize transform",
-        "Glue Elastic Views",
-        "ResolveChoice transform"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "The Relationalize transform in AWS Glue converts nested JSON/semi-structured data into a set of flat tables that can be easily queried with standard SQL.",
-      domain: 1,
-      topic: "Data Transformation",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_8',
-      question: "A media company receives video metadata files in various formats (JSON, XML, CSV) from different content providers. The data must be normalized and stored in a consistent schema. Which approach provides the MOST flexibility?",
-      options: [
-        "Create separate Glue crawlers for each format",
-        "Use AWS Glue classifiers with custom patterns",
-        "Build custom Lambda functions for each format",
-        "Use Amazon Athena with different SerDe configurations"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "AWS Glue classifiers with custom patterns provide the most flexibility for handling various file formats. They can automatically detect and parse different formats, then normalize the data to a consistent schema.",
-      domain: 1,
-      topic: "Data Normalization",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_9',
-      question: "A financial services company needs to process credit card transactions in real-time to detect fraud. The system must handle 50,000 transactions per second with less than 100ms latency. Which architecture is MOST appropriate?",
-      options: [
-        "Kinesis Data Streams with enhanced fan-out consumers",
-        "Kinesis Data Firehose with Lambda transformation",
-        "Amazon SQS FIFO with Lambda",
-        "Amazon MSK with consumer groups"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "Kinesis Data Streams with enhanced fan-out provides dedicated 2 MB/s throughput per consumer with ~70ms propagation delay. This is ideal for real-time fraud detection requiring low latency at high throughput.",
-      domain: 1,
-      topic: "Real-time Processing",
-      difficulty: "hard"
-    },
-    {
-      id: 'd1_10',
-      question: "A data engineer needs to migrate data from Amazon RDS MySQL to Amazon Aurora PostgreSQL. The migration must minimize downtime. Which approach should be used?",
-      options: [
-        "AWS DMS with Schema Conversion Tool (SCT)",
-        "AWS Glue with JDBC connections",
-        "Export/Import using mysqldump and pg_restore",
-        "AWS DataSync between the databases"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "AWS DMS with Schema Conversion Tool (SCT) is designed for heterogeneous database migrations. SCT converts the schema while DMS handles continuous data replication with minimal downtime.",
-      domain: 1,
-      topic: "Database Migration",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_11',
-      question: "A retail company wants to sync data from Salesforce to Amazon S3 on a scheduled basis. The solution should require minimal coding. Which service should be used?",
-      options: [
-        "AWS Glue with custom connectors",
-        "Amazon AppFlow",
-        "AWS Lambda with Salesforce SDK",
-        "Amazon EventBridge with API destinations"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Amazon AppFlow is a fully managed integration service that enables secure data transfer between SaaS applications like Salesforce and AWS services like S3, with no coding required.",
-      domain: 1,
-      topic: "SaaS Integration",
-      difficulty: "easy"
-    },
-    {
-      id: 'd1_12',
-      question: "An e-commerce platform generates clickstream data that needs to be enriched with product catalog information before storage. The enrichment should happen in near real-time. Which solution is MOST efficient?",
-      options: [
-        "Kinesis Data Streams with Lambda enrichment using DynamoDB lookups",
-        "Kinesis Data Firehose with Glue transformation",
-        "S3 event triggers with Step Functions",
-        "EMR Spark Streaming with broadcast variables"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "Kinesis Data Streams with Lambda enrichment using DynamoDB lookups provides near real-time enrichment with single-digit millisecond DynamoDB access times.",
-      domain: 1,
-      topic: "Data Enrichment",
-      difficulty: "hard"
-    },
-    {
-      id: 'd1_13',
-      question: "A healthcare company needs to ingest HL7 FHIR formatted patient data from multiple hospital systems. The data arrives via REST APIs and must be transformed to a standard schema. Which approach minimizes development effort?",
-      options: [
-        "AWS HealthLake with integrated data transformation",
-        "API Gateway with Lambda and custom transformation",
-        "AWS Glue with custom ETL scripts",
-        "Amazon Kinesis with Lambda consumers"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "AWS HealthLake is specifically designed for healthcare data in FHIR format. It provides automatic data transformation, storage, and analytics capabilities with minimal development effort.",
-      domain: 1,
-      topic: "Healthcare Data Ingestion",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_14',
-      question: "A gaming company processes 1 TB of player event data daily. The data arrives continuously and must be available for analysis within 15 minutes. Which ingestion pattern is MOST cost-effective?",
-      options: [
-        "Kinesis Data Streams with Lambda to S3",
-        "Kinesis Data Firehose with 60-second buffering",
-        "Direct S3 PutObject from game servers",
-        "Amazon MSK with S3 Sink Connector"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Kinesis Data Firehose with 60-second buffering is the most cost-effective for this use case. It's fully managed, automatically scales, and the 60-second buffer easily meets the 15-minute availability requirement.",
-      domain: 1,
-      topic: "Cost-Effective Ingestion",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_15',
-      question: "A data engineer needs to deduplicate streaming records before storing them. Records have a unique transaction_id and duplicates can arrive within a 5-minute window. Which approach is MOST efficient?",
-      options: [
-        "Use Kinesis Data Analytics with a 5-minute tumbling window and DISTINCT",
-        "Lambda with DynamoDB for deduplication tracking",
-        "Kinesis Data Streams with Kinesis Client Library (KCL) checkpointing",
-        "Store all records in S3 and deduplicate with Athena"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "Kinesis Data Analytics with SQL can efficiently deduplicate records within a time window using GROUP BY and aggregation. This provides real-time deduplication without managing additional infrastructure.",
-      domain: 1,
-      topic: "Stream Deduplication",
-      difficulty: "hard"
-    },
-    {
-      id: 'd1_16',
-      question: "A company is migrating a legacy ETL system to AWS Glue. The existing jobs use complex stored procedures in Oracle. How should the data engineer approach this migration?",
-      options: [
-        "Rewrite all logic in PySpark for AWS Glue",
-        "Use AWS Glue with Oracle JDBC and call stored procedures",
-        "Convert procedures using AWS SCT, then implement in Glue",
-        "Keep stored procedures and use AWS DMS for data movement"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "AWS Schema Conversion Tool (SCT) can convert Oracle stored procedures to equivalent AWS Glue ETL code (PySpark/Scala), reducing manual rewriting effort while ensuring logic is properly migrated.",
-      domain: 1,
-      topic: "ETL Migration",
-      difficulty: "hard"
-    },
-    {
-      id: 'd1_17',
-      question: "A logistics company needs to process GPS coordinates from 10,000 delivery vehicles in real-time. Each vehicle sends location updates every 5 seconds. The data must be stored for route optimization analysis. Which architecture handles this efficiently?",
-      options: [
-        "IoT Core  IoT Rules  Kinesis Data Firehose  S3",
-        "API Gateway  Lambda  DynamoDB",
-        "IoT Core  IoT Analytics  QuickSight",
-        "Direct MQTT to EC2 instances with custom processing"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "IoT Core with IoT Rules to Kinesis Data Firehose to S3 efficiently handles high-volume IoT data ingestion. IoT Core manages device connections while Firehose handles reliable delivery to S3.",
-      domain: 1,
-      topic: "IoT Data Ingestion",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_18',
-      question: "A data pipeline must process files that arrive in S3 in any order but must be processed in sequence based on a timestamp in the filename. Which approach ensures correct ordering?",
-      options: [
-        "Use S3 event notifications to trigger Lambda immediately",
-        "Use AWS Glue workflow with job bookmarks",
-        "Implement a Step Functions workflow with file ordering logic",
-        "Use S3 Batch Operations for sequential processing"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "Step Functions can implement custom ordering logic to sort files by timestamp and process them sequentially. This provides explicit control over processing order regardless of arrival time.",
-      domain: 1,
-      topic: "Ordered Processing",
-      difficulty: "hard"
-    },
-    {
-      id: 'd1_19',
-      question: "A data engineer needs to incrementally load data from a source system that doesn't support change data capture. The source table has 100 million rows with a last_modified timestamp column. Which approach is MOST efficient?",
-      options: [
-        "Full table extraction daily",
-        "AWS Glue job with bookmark on last_modified column",
-        "AWS DMS with full load only",
-        "Athena CTAS with date filter"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "AWS Glue job bookmarks can track the last processed value of the last_modified column, enabling efficient incremental loads without full table scans on each run.",
-      domain: 1,
-      topic: "Incremental Loading",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_20',
-      question: "A company uses multiple AWS accounts for different departments. Data from all accounts must be consolidated in a central data lake. Which approach simplifies cross-account data ingestion?",
-      options: [
-        "Set up VPC peering between all accounts",
-        "Use S3 replication with cross-account bucket policies",
-        "Configure AWS RAM to share S3 buckets",
-        "Build custom Lambda functions in each account"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "S3 replication with cross-account bucket policies is the most straightforward approach. S3 replication rules can automatically copy objects to a central bucket with proper IAM permissions.",
-      domain: 1,
-      topic: "Cross-Account Ingestion",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_21',
-      question: "An AWS Glue job reads from a JDBC source and writes to S3 in Parquet format. The job is slow due to the JDBC connection being a bottleneck. How can the data engineer improve performance? (Select TWO)",
-      options: [
-        "Enable parallel reads using hashfield or hashpartitions",
-        "Increase the number of Glue DPUs",
-        "Use pushdown predicates to filter at the source",
-        "Switch to Glue version 1.0",
-        "Enable Glue job metrics"
-      ],
-      correctAnswer: null,
-      correctAnswers: [0, 2],
-      type: "multiple",
-      selectCount: 2,
-      explanation: "Enabling parallel reads (hashfield/hashpartitions) and pushdown predicates reduces JDBC bottleneck. Parallel reads split the table across multiple connections, and pushdown predicates minimize data transferred from source.",
-      domain: 1,
-      topic: "JDBC Optimization",
-      difficulty: "hard"
-    },
-    {
-      id: 'd1_22',
-      question: "A streaming application needs exactly-once semantics when writing to Amazon S3 from Kinesis Data Streams. Which approach guarantees this?",
-      options: [
-        "Use Kinesis Data Firehose with S3 destination",
-        "Implement idempotent writes in Lambda with DynamoDB tracking",
-        "Use Kinesis Data Analytics for Flink with exactly-once checkpointing",
-        "Configure Kinesis enhanced fan-out consumers"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "Kinesis Data Analytics for Apache Flink provides exactly-once processing semantics through its checkpointing mechanism, ensuring no data loss or duplication when writing to sinks like S3.",
-      domain: 1,
-      topic: "Exactly-Once Processing",
-      difficulty: "hard"
-    },
-    {
-      id: 'd1_23',
-      question: "A data engineer needs to validate incoming data quality before loading to the data warehouse. Records failing validation should be sent to a dead-letter queue for investigation. Which service combination achieves this?",
-      options: [
-        "AWS Glue with Data Quality rules and SQS DLQ",
-        "Lambda with custom validation and SNS notifications",
-        "Kinesis Data Analytics with error output stream",
-        "Step Functions with Choice states and SQS"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "AWS Glue Data Quality allows defining validation rules (DQDL) and can route failed records to an SQS dead-letter queue, providing an integrated solution for data quality validation.",
-      domain: 1,
-      topic: "Data Quality",
-      difficulty: "medium"
-    },
-    {
-      id: 'd1_24',
-      question: "A company receives data files encrypted with customer-provided keys. The data must be re-encrypted with AWS-managed keys after ingestion. Which approach is MOST secure?",
-      options: [
-        "Decrypt in Lambda, then upload to S3 with SSE-KMS",
-        "Use S3 Batch Operations with decryption and re-encryption",
-        "Transfer via AWS Transfer Family with post-processing Lambda",
-        "Use AWS Glue with temporary decryption in memory"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "AWS Transfer Family provides secure file transfer with automatic integration to S3. Post-processing Lambda can re-encrypt files with KMS, keeping plaintext data only in Lambda's secure execution environment.",
-      domain: 1,
-      topic: "Encryption Handling",
-      difficulty: "hard"
-    }
-  ],
-
-  // Domain 2: Data Store Management (26% - 18 questions)
-  2: [
-    {
-      id: 'd2_1',
-      question: "A data lake on Amazon S3 contains 50 TB of data. Users query this data using Amazon Athena but report slow performance. The data is stored in CSV format with no partitioning. Which optimization will provide the GREATEST performance improvement?",
-      options: [
-        "Enable S3 Transfer Acceleration",
-        "Convert data to Parquet format and implement partitioning",
-        "Increase Athena query timeout settings",
-        "Move data to Amazon EFS for faster access"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Converting to Parquet (columnar, compressed) and implementing partitioning will dramatically improve Athena query performance. Parquet enables column pruning and compression, while partitioning allows Athena to scan only relevant data partitions.",
-      domain: 2,
-      topic: "Query Optimization",
-      difficulty: "medium"
-    },
-    {
-      id: 'd2_2',
-      question: "A company stores transaction data in Amazon Redshift. Query performance has degraded over time. Analysis shows that the distribution style is causing data skew. The main table has a transaction_id column and a customer_id column. Queries frequently join on customer_id. What should be done?",
-      options: [
-        "Change the distribution style to EVEN",
-        "Change the distribution key to customer_id",
-        "Add a sort key on transaction_id",
-        "Increase the number of nodes in the cluster"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Changing the distribution key to customer_id will collocate data for the frequently used join column, reducing data movement during queries. This directly addresses the data skew issue.",
-      domain: 2,
-      topic: "Redshift Optimization",
-      difficulty: "hard"
-    },
-    {
-      id: 'd2_3',
-      question: "A data engineer needs to design a DynamoDB table for a gaming application. The table will store player sessions with access patterns: 1) Get all sessions for a player, 2) Get sessions by game type for a player, 3) Get sessions within a date range for a player. What is the optimal key design?",
-      options: [
-        "Partition key: session_id",
-        "Partition key: player_id, Sort key: game_type#session_date",
-        "Partition key: player_id, Sort key: session_date, GSI on game_type",
-        "Partition key: game_type, Sort key: player_id"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Using player_id as partition key with a composite sort key (game_type#session_date) supports all three access patterns. Query on player_id gets all sessions, begins_with on sort key filters by game_type.",
-      domain: 2,
-      topic: "DynamoDB Design",
-      difficulty: "hard"
-    },
-    {
-      id: 'd2_4',
-      question: "An organization needs to store 100 TB of log data in S3. The data is queried infrequently (once per month) but must be available within 12 hours when needed. Which S3 storage class is MOST cost-effective?",
-      options: [
-        "S3 Standard",
-        "S3 Intelligent-Tiering",
-        "S3 Glacier Flexible Retrieval",
-        "S3 Glacier Deep Archive"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "S3 Glacier Flexible Retrieval is most cost-effective for infrequently accessed data needing retrieval within 3-12 hours. It's significantly cheaper than Standard for this access pattern.",
-      domain: 2,
-      topic: "S3 Storage Classes",
-      difficulty: "medium"
-    },
-    {
-      id: 'd2_5',
-      question: "A company wants to build a data lake with: centralized data catalog, fine-grained access control at column level, and automatic schema discovery. Which AWS services should be used? (Select TWO)",
-      options: [
-        "AWS Lake Formation",
-        "Amazon Macie",
-        "AWS Glue Data Catalog",
-        "Amazon Redshift Spectrum",
-        "AWS Config"
-      ],
-      correctAnswer: null,
-      correctAnswers: [0, 2],
-      type: "multiple",
-      selectCount: 2,
-      explanation: "AWS Lake Formation provides fine-grained access control (column-level) and integrates with the Glue Data Catalog for centralized metadata management. Glue Crawlers provide automatic schema discovery.",
-      domain: 2,
-      topic: "Data Lake Architecture",
-      difficulty: "medium"
-    },
-    {
-      id: 'd2_6',
-      question: "A Redshift cluster uses RA3 nodes. The data warehouse team wants to share data with another AWS account without copying the data. What feature should they use?",
-      options: [
-        "Redshift Spectrum",
-        "Redshift Data Sharing",
-        "AWS Data Exchange",
-        "S3 Cross-Account Access"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Redshift Data Sharing allows sharing live data between Redshift clusters across AWS accounts without physically copying the data. This is a native Redshift feature for RA3 nodes.",
-      domain: 2,
-      topic: "Data Sharing",
-      difficulty: "medium"
-    },
-    {
-      id: 'd2_7',
-      question: "A data warehouse query that previously took 10 seconds now takes 2 minutes. The table hasn't changed in size, but maintenance hasn't been run recently. Which Redshift maintenance task should be performed first?",
-      options: [
-        "VACUUM to reclaim space and resort rows",
-        "ANALYZE to update statistics",
-        "Resize the cluster",
-        "Modify the distribution key"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "ANALYZE updates table statistics that the query planner uses. Stale statistics cause poor query plans. This is the most likely cause when table size hasn't changed but performance degraded.",
-      domain: 2,
-      topic: "Redshift Maintenance",
-      difficulty: "medium"
-    },
-    {
-      id: 'd2_8',
-      question: "A company stores time-series data in DynamoDB for IoT sensor readings. Each sensor writes 1 KB records every second. After 30 days, data should be moved to cold storage. Which approach is MOST cost-effective?",
-      options: [
-        "Use DynamoDB TTL with S3 export",
-        "Use DynamoDB Streams with Lambda to archive to S3 Glacier",
-        "Enable DynamoDB Global Tables for replication",
-        "Use DynamoDB on-demand capacity mode"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "DynamoDB Streams with Lambda provides automatic archival workflow. When TTL deletes items, Streams captures the deletion, Lambda can write the data to S3 Glacier before it's removed.",
-      domain: 2,
-      topic: "Data Lifecycle",
-      difficulty: "hard"
-    },
-    {
-      id: 'd2_9',
-      question: "A data lake uses S3 with millions of small files (1-10 KB each). Athena queries are slow despite using Parquet format. What optimization should be implemented?",
-      options: [
-        "Enable S3 Transfer Acceleration",
-        "Compact small files into larger files (128MB-1GB)",
-        "Change to ORC format",
-        "Use S3 Intelligent-Tiering"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Small files create overhead as Athena must open each file separately. Compacting into larger files (128MB-1GB) reduces S3 API calls and improves query performance significantly.",
-      domain: 2,
-      topic: "File Optimization",
-      difficulty: "medium"
-    },
-    {
-      id: 'd2_10',
-      question: "A company runs complex analytical queries on Amazon Redshift. Some queries scan fact tables with billions of rows. The data engineer notices queries don't use zone maps effectively. What is the MOST likely cause?",
-      options: [
-        "Sort keys are not defined on frequently filtered columns",
-        "Distribution style is set to EVEN",
-        "The cluster has too few nodes",
-        "Workload Management (WLM) queues are misconfigured"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "Zone maps work with sort keys to skip blocks of data. Without proper sort keys on filtered columns, Redshift cannot use zone maps effectively for query optimization.",
-      domain: 2,
-      topic: "Redshift Performance",
-      difficulty: "hard"
-    },
-    {
-      id: 'd2_11',
-      question: "A data lake stores customer data that must comply with GDPR right-to-erasure requirements. Data is stored in Parquet format on S3 and cataloged in Glue. How should deletion requests be handled efficiently?",
-      options: [
-        "Rewrite entire Parquet files without deleted records",
-        "Use S3 Object Lock to prevent deletion",
-        "Implement Delta Lake or Apache Iceberg for record-level operations",
-        "Delete entire partitions containing the customer"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "Delta Lake or Apache Iceberg support ACID transactions and efficient record-level deletes. They track deleted records in metadata without rewriting entire files.",
-      domain: 2,
-      topic: "Data Lake ACID",
-      difficulty: "hard"
-    },
-    {
-      id: 'd2_12',
-      question: "An analytics workload on Redshift has unpredictable query patterns. Sometimes there are no queries for hours, then sudden bursts of complex queries. Which pricing model is MOST cost-effective?",
-      options: [
-        "Provisioned Redshift cluster with reserved instances",
-        "Redshift Serverless",
-        "Provisioned cluster with Concurrency Scaling",
-        "Multiple provisioned clusters in different regions"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Redshift Serverless automatically scales up during query bursts and scales to zero during idle periods. This is ideal for unpredictable workloads, charging only for actual usage.",
-      domain: 2,
-      topic: "Cost Optimization",
-      difficulty: "medium"
-    },
-    {
-      id: 'd2_13',
-      question: "A data engineer needs to query data across S3 data lake and Redshift tables in a single query. Which feature enables this?",
-      options: [
-        "Redshift Federated Query",
-        "Redshift Spectrum",
-        "AWS Glue ETL",
-        "Amazon Athena Federated Query"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Redshift Spectrum allows querying S3 data directly from Redshift using external tables. You can join Spectrum external tables with native Redshift tables in a single query.",
-      domain: 2,
-      topic: "Data Federation",
-      difficulty: "medium"
-    },
-    {
-      id: 'd2_14',
-      question: "A company migrates from on-premises Hadoop to AWS. The existing data lake uses Hive with ORC files. They want to minimize changes to existing ETL jobs. Which AWS service should host the metastore?",
-      options: [
-        "AWS Glue Data Catalog with Hive-compatible interface",
-        "Amazon RDS MySQL as external Hive metastore",
-        "Amazon DynamoDB for metadata storage",
-        "AWS Lake Formation with new metadata format"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "AWS Glue Data Catalog is Hive metastore compatible. It can serve as a drop-in replacement for Hive metastore, minimizing changes to existing ETL jobs that use HiveContext or SparkSQL.",
-      domain: 2,
-      topic: "Metadata Management",
-      difficulty: "medium"
-    },
-    {
-      id: 'd2_15',
-      question: "A data lake has grown to 500 TB across 10,000 tables. Different teams need access to different subsets of data. Managing individual IAM policies has become complex. Which solution simplifies access control?",
-      options: [
-        "Create IAM groups for each team",
-        "Use S3 bucket policies with prefixes",
-        "Implement Lake Formation with tag-based access control",
-        "Set up VPC endpoints for each team"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "Lake Formation tag-based access control (LF-TBAC) allows tagging resources and defining access based on tags. This scales much better than managing individual resource policies.",
-      domain: 2,
-      topic: "Access Control",
-      difficulty: "medium"
-    },
-    {
-      id: 'd2_16',
-      question: "A Redshift cluster stores 10 TB of data with 5 years of history. 90% of queries access only the last 3 months of data. How should data be organized for optimal cost and performance?",
-      options: [
-        "Archive old data to S3, keep recent data in Redshift, use Spectrum for historical queries",
-        "Keep all data in Redshift with interleaved sort keys",
-        "Move all data to S3 and use Athena exclusively",
-        "Create separate Redshift clusters for historical and recent data"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "Archiving older data to S3 and querying via Spectrum reduces Redshift storage costs while keeping recent hot data in Redshift for performance.",
-      domain: 2,
-      topic: "Hot/Cold Data",
-      difficulty: "hard"
-    },
-    {
-      id: 'd2_17',
-      question: "A DynamoDB table serves both transactional and analytical workloads. Analytical queries cause throttling on the main table. Which solution addresses this without affecting transactions?",
-      options: [
-        "Increase provisioned capacity",
-        "Enable DynamoDB Global Tables",
-        "Export data to S3 and use Athena for analytics",
-        "Create a Global Secondary Index for analytical queries"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "Exporting DynamoDB data to S3 and using Athena separates analytical workloads from transactional. This prevents analytics from consuming capacity that impacts transactional queries.",
-      domain: 2,
-      topic: "Workload Separation",
-      difficulty: "medium"
-    },
-    {
-      id: 'd2_18',
-      question: "A data lake team needs to maintain multiple versions of datasets for reproducibility. Users should be able to query historical states of data. Which approach provides this capability?",
-      options: [
-        "S3 versioning with Athena",
-        "Apache Iceberg tables with time travel",
-        "Glue job bookmarks",
-        "S3 replication to backup bucket"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Apache Iceberg supports time travel queries allowing users to query data as of a specific timestamp or snapshot. This provides data versioning with efficient storage and query capabilities.",
-      domain: 2,
-      topic: "Data Versioning",
-      difficulty: "hard"
-    }
-  ],
-
-  // Domain 3: Data Operations and Support (22% - 15 questions)
-  3: [
-    {
-      id: 'd3_1',
-      question: "A data pipeline runs daily at 2 AM using Amazon MWAA (Managed Airflow). The pipeline has started failing intermittently. What should the data engineer use to identify the root cause?",
-      options: [
-        "Check AWS CloudTrail logs only",
-        "Review Airflow task logs in CloudWatch Logs and MWAA metrics",
-        "Enable VPC Flow Logs",
-        "Check S3 access logs"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Amazon MWAA integrates with CloudWatch Logs for Airflow task logs and provides MWAA-specific metrics in CloudWatch. This combination provides visibility into task execution for troubleshooting.",
-      domain: 3,
-      topic: "Monitoring and Logging",
-      difficulty: "medium"
-    },
-    {
-      id: 'd3_2',
-      question: "A company needs to implement data quality checks in their AWS Glue ETL pipeline. They want to validate that email addresses match a valid format and customer_id has no null values. What should they use?",
-      options: [
-        "AWS Glue DataBrew data profiling",
-        "AWS Glue Data Quality with DQDL rules",
-        "Custom PySpark validation code in Glue",
-        "Amazon Athena queries after loading"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "AWS Glue Data Quality with Data Quality Definition Language (DQDL) allows defining validation rules like CustomSql, ColumnValues, and Completeness checks natively in Glue ETL.",
-      domain: 3,
-      topic: "Data Quality",
-      difficulty: "medium"
-    },
-    {
-      id: 'd3_3',
-      question: "An ETL pipeline uses AWS Step Functions to orchestrate AWS Glue jobs. The team needs to receive alerts when any job fails. What is the MOST efficient way to implement this?",
-      options: [
-        "Add a Catch state that invokes Lambda to send SNS notifications",
-        "Create CloudWatch Alarms for each Glue job",
-        "Poll Step Functions execution status using Lambda",
-        "Enable AWS Config rules for Step Functions"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "Using a Catch state in Step Functions that invokes Lambda to send SNS notifications provides centralized error handling at the workflow level and immediate notifications.",
-      domain: 3,
-      topic: "Alerting",
-      difficulty: "medium"
-    },
-    {
-      id: 'd3_4',
-      question: "A data engineer needs to optimize costs for an AWS Glue ETL workload that runs 4 hours daily. The job uses 20 DPUs. What cost optimization strategy should be considered?",
-      options: [
-        "Use Glue Auto Scaling to optimize DPU usage",
-        "Run the job on Amazon EMR instead",
-        "Increase DPUs to complete faster",
-        "Use Glue version 0.9 for lower costs"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "AWS Glue Auto Scaling automatically adjusts workers based on actual resource needs. This can significantly reduce costs by using fewer DPUs when full capacity isn't needed.",
-      domain: 3,
-      topic: "Cost Optimization",
-      difficulty: "medium"
-    },
-    {
-      id: 'd3_5',
-      question: "A company needs to implement a data pipeline that triggers when new files arrive in S3. The pipeline should process files in order and handle retries automatically. Which orchestration approach is recommended?",
-      options: [
-        "S3 Event  SNS  Lambda",
-        "S3 Event  EventBridge  Step Functions",
-        "S3 Event  SQS  Lambda (polling)",
-        "CloudWatch Events  Lambda  Glue"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "S3 Event to EventBridge to Step Functions provides reliable event capture with built-in retry logic, error handling, and execution state management.",
-      domain: 3,
-      topic: "Event-Driven Architecture",
-      difficulty: "hard"
-    },
-    {
-      id: 'd3_6',
-      question: "A data team runs 50+ Glue jobs with complex dependencies. Managing job scheduling and dependencies has become difficult. Which solution provides better orchestration?",
-      options: [
-        "AWS Glue Workflows",
-        "EventBridge Scheduler with Lambda",
-        "Amazon MWAA (Managed Apache Airflow)",
-        "Step Functions Standard Workflows"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "Amazon MWAA provides a full-featured workflow orchestration with rich DAG visualization, dependency management, and extensive operator ecosystem for complex job dependencies.",
-      domain: 3,
-      topic: "Workflow Orchestration",
-      difficulty: "medium"
-    },
-    {
-      id: 'd3_7',
-      question: "A streaming pipeline occasionally drops records during high-volume periods. The data engineer needs to identify which records were lost and from which source. Which approach enables this investigation?",
-      options: [
-        "Enable CloudWatch detailed monitoring",
-        "Implement record counting at each pipeline stage with reconciliation",
-        "Increase Kinesis shard count",
-        "Enable S3 server access logging"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Implementing record counting at each stage allows reconciliation between source and destination. This identifies exactly where and how many records are lost in the pipeline.",
-      domain: 3,
-      topic: "Data Reconciliation",
-      difficulty: "hard"
-    },
-    {
-      id: 'd3_8',
-      question: "An AWS Glue job writes data to S3, but downstream consumers occasionally see incomplete data. The job logs show successful completion. What is the MOST likely cause?",
-      options: [
-        "Eventual consistency of S3",
-        "Glue job is not committing the transaction",
-        "Files are being written without _SUCCESS marker or manifest",
-        "CloudWatch logs are delayed"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "Without a _SUCCESS marker or manifest file, downstream consumers may read incomplete data as Glue writes multiple files. The marker signals job completion for safe consumption.",
-      domain: 3,
-      topic: "Job Completion Signaling",
-      difficulty: "hard"
-    },
-    {
-      id: 'd3_9',
-      question: "A company needs to run Spark jobs on EMR but wants to minimize cluster management overhead. Jobs run for 2-4 hours daily. Which EMR deployment option is MOST suitable?",
-      options: [
-        "EMR on EC2 with long-running cluster",
-        "EMR on EKS",
-        "EMR Serverless",
-        "EMR on EC2 with transient clusters"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "EMR Serverless eliminates cluster management entirely. Jobs run without provisioning or managing clusters. For 2-4 hour daily jobs, this provides minimal overhead and pay-per-use billing.",
-      domain: 3,
-      topic: "Managed Services",
-      difficulty: "medium"
-    },
-    {
-      id: 'd3_10',
-      question: "A data pipeline must meet an SLA of 99.9% availability. The pipeline uses Lambda, Glue, and S3. Which monitoring strategy ensures SLA compliance?",
-      options: [
-        "CloudWatch Logs only",
-        "Custom dashboard with CloudWatch Metrics, Alarms, and automated remediation",
-        "AWS X-Ray tracing only",
-        "Manual log review daily"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "A comprehensive monitoring strategy with CloudWatch Metrics for uptime tracking, Alarms for immediate detection, and automated remediation ensures 99.9% SLA compliance.",
-      domain: 3,
-      topic: "SLA Monitoring",
-      difficulty: "medium"
-    },
-    {
-      id: 'd3_11',
-      question: "A Glue job processes data from multiple S3 prefixes. The job should only process new files since the last successful run. Which feature enables this?",
-      options: [
-        "S3 Inventory",
-        "AWS Glue job bookmarks",
-        "S3 event notifications",
-        "AWS Glue triggers"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Glue job bookmarks track which files have been processed, allowing the job to automatically process only new or unprocessed files in subsequent runs.",
-      domain: 3,
-      topic: "Incremental Processing",
-      difficulty: "easy"
-    },
-    {
-      id: 'd3_12',
-      question: "A data pipeline team needs to implement blue-green deployment for their ETL jobs. How should they approach this for AWS Glue jobs?",
-      options: [
-        "Use Glue versions feature",
-        "Maintain separate job definitions with version suffixes and swap aliases",
-        "Use AWS CodePipeline with Glue deployment actions",
-        "Clone jobs manually before updates"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Maintaining separate job definitions (blue/green versions) with workflow aliases allows safe deployment. Test the new version, then swap the alias to point to green, enabling instant rollback.",
-      domain: 3,
-      topic: "Deployment Strategy",
-      difficulty: "hard"
-    },
-    {
-      id: 'd3_13',
-      question: "An MWAA environment runs out of memory when running many parallel tasks. Task logs show OOM errors. What should be modified? (Select TWO)",
-      options: [
-        "Increase MWAA environment size",
-        "Reduce parallelism configuration in Airflow",
-        "Use larger S3 bucket",
-        "Enable MWAA auto-scaling",
-        "Reduce DAG complexity"
-      ],
-      correctAnswer: null,
-      correctAnswers: [0, 1],
-      type: "multiple",
-      selectCount: 2,
-      explanation: "Increasing MWAA environment size provides more memory. Reducing parallelism limits concurrent tasks, preventing memory exhaustion. Both directly address OOM issues.",
-      domain: 3,
-      topic: "MWAA Tuning",
-      difficulty: "hard"
-    },
-    {
-      id: 'd3_14',
-      question: "A data team wants to implement CI/CD for their Glue ETL scripts stored in Git. Which AWS service best integrates with Git for automated Glue deployments?",
-      options: [
-        "AWS CodePipeline with CodeBuild",
-        "AWS CloudFormation StackSets",
-        "AWS Systems Manager Automation",
-        "AWS Glue DevEndpoints"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "AWS CodePipeline integrates with Git repositories (CodeCommit, GitHub) and can use CodeBuild to test and deploy Glue ETL scripts automatically when changes are pushed.",
-      domain: 3,
-      topic: "CI/CD",
-      difficulty: "medium"
-    },
-    {
-      id: 'd3_15',
-      question: "A company needs to replay failed Kinesis stream records from 6 hours ago. The stream retention is set to 24 hours. How should the data engineer accomplish this?",
-      options: [
-        "Use GetShardIterator with AT_TIMESTAMP",
-        "Restore from Kinesis backup",
-        "Use Kinesis Data Firehose error logging",
-        "Increase stream retention to 7 days"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "GetShardIterator with AT_TIMESTAMP allows reading from a specific point in time within the retention period. This enables replaying records from exactly when failures occurred.",
-      domain: 3,
-      topic: "Stream Replay",
-      difficulty: "hard"
-    }
-  ],
-
-  // Domain 4: Data Security and Governance (18% - 12 questions)
-  4: [
-    {
-      id: 'd4_1',
-      question: "A company needs to ensure that sensitive customer data in Amazon S3 is encrypted with keys that the company manages and can rotate annually. What should be implemented?",
-      options: [
-        "S3 Server-Side Encryption with S3-Managed Keys (SSE-S3)",
-        "S3 Server-Side Encryption with KMS Customer Managed Keys (SSE-KMS)",
-        "Client-side encryption before upload",
-        "S3 Server-Side Encryption with Customer-Provided Keys (SSE-C)"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "SSE-KMS with Customer Managed Keys (CMK) allows the company to manage keys in AWS KMS, including automatic annual rotation. KMS provides audit trails through CloudTrail.",
-      domain: 4,
-      topic: "Encryption",
-      difficulty: "medium"
-    },
-    {
-      id: 'd4_2',
-      question: "A data lake uses AWS Lake Formation for access control. A new analyst needs read access to only the 'name' and 'email' columns in 'customers' table, but not 'ssn' or 'credit_card' columns. How should this be implemented?",
-      options: [
-        "Create an IAM policy with column-level S3 object permissions",
-        "Use Lake Formation column-level security grants",
-        "Create a view in Athena that excludes sensitive columns",
-        "Use S3 Access Points with column filtering"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "AWS Lake Formation supports column-level security grants, allowing you to grant SELECT permission on specific columns to users or groups.",
-      domain: 4,
-      topic: "Access Control",
-      difficulty: "medium"
-    },
-    {
-      id: 'd4_3',
-      question: "A company stores data in Amazon Redshift that contains PII. Regulatory requirements mandate that all queries accessing PII columns must be logged. Which feature should be enabled?",
-      options: [
-        "Redshift Audit Logging to S3",
-        "VPC Flow Logs",
-        "AWS CloudTrail data events",
-        "Amazon CloudWatch Logs Insights"
-      ],
-      correctAnswer: 0,
-      correctAnswers: [0],
-      type: "single",
-      explanation: "Redshift Audit Logging captures user activity including SQL statements. Logs can be stored in S3 for analysis and compliance.",
-      domain: 4,
-      topic: "Audit Logging",
-      difficulty: "medium"
-    },
-    {
-      id: 'd4_4',
-      question: "An AWS Glue ETL job needs to access credentials for a third-party database. The credentials must be encrypted and automatically rotated. Which service should store these credentials?",
-      options: [
-        "AWS Systems Manager Parameter Store (SecureString)",
-        "AWS Secrets Manager with rotation enabled",
-        "Hardcode in AWS Glue job parameters (encrypted)",
-        "Store in a private S3 bucket with SSE-S3"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "AWS Secrets Manager supports automatic credential rotation with built-in Lambda functions. Glue can retrieve secrets at runtime using the Secrets Manager API.",
-      domain: 4,
-      topic: "Secrets Management",
-      difficulty: "medium"
-    },
-    {
-      id: 'd4_5',
-      question: "A data lake needs to track data lineage to understand how data flows from source to final reports. Which AWS service provides this capability?",
-      options: [
-        "AWS X-Ray",
-        "AWS CloudTrail",
-        "AWS Glue Data Catalog with lineage tracking",
-        "Amazon Detective"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "AWS Glue Data Catalog can track data lineage through Glue jobs, showing how tables are created and transformed. Lake Formation also provides lineage views.",
-      domain: 4,
-      topic: "Data Lineage",
-      difficulty: "medium"
-    },
-    {
-      id: 'd4_6',
-      question: "A company needs to automatically discover and classify sensitive data (PII, financial data) stored across S3 buckets in their data lake. Which service should be used?",
-      options: [
-        "AWS Config",
-        "Amazon Macie",
-        "Amazon Inspector",
-        "AWS Trusted Advisor"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Amazon Macie uses machine learning to automatically discover, classify, and protect sensitive data in S3. It can identify PII, financial data, and other sensitive information types.",
-      domain: 4,
-      topic: "Data Discovery",
-      difficulty: "easy"
-    },
-    {
-      id: 'd4_7',
-      question: "A company must comply with data residency requirements ensuring certain data never leaves a specific AWS region. How should this be enforced for S3?",
-      options: [
-        "Use S3 Object Lock",
-        "Configure S3 bucket policies with aws:RequestedRegion condition",
-        "Enable S3 Cross-Region Replication blocking",
-        "Use AWS Organizations SCP to deny cross-region operations"
-      ],
-      correctAnswer: 3,
-      correctAnswers: [3],
-      type: "single",
-      explanation: "AWS Organizations Service Control Policies (SCPs) can enforce region restrictions at the organization level, preventing any cross-region operations.",
-      domain: 4,
-      topic: "Data Residency",
-      difficulty: "hard"
-    },
-    {
-      id: 'd4_8',
-      question: "A data pipeline processes data from external partners. The data should be scanned for malware before processing. Which approach is MOST appropriate?",
-      options: [
-        "Use AWS WAF on the ingestion endpoint",
-        "Implement Lambda-based scanning using ClamAV or similar",
-        "Enable S3 Object Lambda for scanning on access",
-        "Use Amazon GuardDuty for S3"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "Lambda-based malware scanning (using ClamAV or commercial tools) triggered by S3 upload events provides file-level malware detection before processing.",
-      domain: 4,
-      topic: "Security Scanning",
-      difficulty: "medium"
-    },
-    {
-      id: 'd4_9',
-      question: "A data warehouse team needs to implement dynamic data masking in Redshift. Certain users should see actual SSN values while others see masked versions. Which approach works?",
-      options: [
-        "Create separate tables for different user groups",
-        "Use Redshift row-level security (RLS)",
-        "Create views with CASE statements based on current_user and grant access to views",
-        "Use Redshift column-level encryption"
-      ],
-      correctAnswer: 2,
-      correctAnswers: [2],
-      type: "single",
-      explanation: "Creating views with conditional logic based on current_user allows showing real or masked data based on who is querying. This provides dynamic masking without data duplication.",
-      domain: 4,
-      topic: "Data Masking",
-      difficulty: "hard"
-    },
-    {
-      id: 'd4_10',
-      question: "A company uses Kinesis Data Streams for sensitive financial data. They require encryption in transit and at rest. Which configuration ensures this? (Select TWO)",
-      options: [
-        "Enable server-side encryption on the Kinesis stream",
-        "Use HTTPS endpoints for producers and consumers",
-        "Enable VPC flow logs",
-        "Use IAM roles instead of access keys",
-        "Enable CloudTrail logging"
-      ],
-      correctAnswer: null,
-      correctAnswers: [0, 1],
-      type: "multiple",
-      selectCount: 2,
-      explanation: "Server-side encryption (SSE) protects data at rest in Kinesis. HTTPS endpoints ensure encryption in transit. Together they provide complete encryption coverage.",
-      domain: 4,
-      topic: "Stream Security",
-      difficulty: "medium"
-    },
-    {
-      id: 'd4_11',
-      question: "A data lake processes healthcare data subject to HIPAA. Data in S3 must be encrypted, and access must be logged for audit. Which combination of services ensures compliance? (Select TWO)",
-      options: [
-        "S3 SSE-KMS encryption",
-        "AWS CloudTrail with S3 data events",
-        "Amazon Macie",
-        "AWS Config",
-        "S3 Transfer Acceleration"
-      ],
-      correctAnswer: null,
-      correctAnswers: [0, 1],
-      type: "multiple",
-      selectCount: 2,
-      explanation: "SSE-KMS provides HIPAA-compliant encryption with key management. CloudTrail with S3 data events logs all access for audit requirements.",
-      domain: 4,
-      topic: "HIPAA Compliance",
-      difficulty: "medium"
-    },
-    {
-      id: 'd4_12',
-      question: "A Glue job needs to access resources in a private subnet with no internet access. The job must read from S3 and write to Redshift. What network configuration is required?",
-      options: [
-        "NAT Gateway for S3 and Redshift access",
-        "VPC endpoints for S3 and Redshift",
-        "Internet Gateway with security groups",
-        "AWS PrivateLink for S3 only"
-      ],
-      correctAnswer: 1,
-      correctAnswers: [1],
-      type: "single",
-      explanation: "VPC endpoints (Gateway endpoint for S3, Interface endpoint for Redshift) allow private subnet access without internet. This maintains security while enabling necessary connectivity.",
-      domain: 4,
-      topic: "Network Security",
-      difficulty: "medium"
-    }
-  ]
-}
-
-export default function AWSExam() {
-  const { sessionId } = useParams()
-  const location = useLocation()
-  const navigate = useNavigate()
-  const { user } = useAuth()
-
-  const [questions, setQuestions] = useState([])
-  const [currentIndex, setCurrentIndex] = useState(0)
-  const [answers, setAnswers] = useState({})
-  const [flagged, setFlagged] = useState([])
-  const [timeLeft, setTimeLeft] = useState(0)
-  const [phase, setPhase] = useState('loading')
-  const [showExplanation, setShowExplanation] = useState(false)
-  const [results, setResults] = useState(null)
-  const [examConfig, setExamConfig] = useState(null)
-
-  useEffect(() => {
-    loadExam()
-  }, [])
-
-  useEffect(() => {
-    if (phase !== 'running' || timeLeft <= 0 || examConfig?.mode === 'review') return
-
-    const timer = setInterval(() => {
-      setTimeLeft(prev => {
-        if (prev <= 1) {
-          clearInterval(timer)
-          submitExam()
-          return 0
-        }
-        return prev - 1
-      })
-    }, 1000)
-
-    return () => clearInterval(timer)
-  }, [phase, timeLeft])
-
-  const loadExam = async () => {
-    try {
-      const config = location.state
-      if (!config) {
-        navigate('/aws-certification')
-        return
-      }
-
-      // Force config for Random Mix
-      if (config.paper === 'random-mix') {
-        config.questionCount = 65
-        config.duration = 130
-      }
-
-      setExamConfig(config)
-
-      let selectedQuestions = []
-
-      // Handling Random Mix with Domain Weightage
-      if (config.paper === 'random-mix') {
-        const allQuestions = [
-          ...DEA_C01_PRACTICE_QUESTIONS,
-          ...DEA_C01_PAPER_2_QUESTIONS,
-          ...DEA_C01_PAPER_3_QUESTIONS,
-          ...DEA_C01_PAPER_4_QUESTIONS,
-          ...DEA_C01_PAPER_5_QUESTIONS,
-          ...DEA_C01_PAPER_6_QUESTIONS,
-          ...DEA_C01_PAPER_8_QUESTIONS
-        ]
-
-        // 1. Map domains with refined logic
-        const mappedQuestions = allQuestions.map(q => {
-          const t = (q.topic || '').toLowerCase()
-          let domain = 4 // Default to Security & Governance if unclassified
-
-          // Domain 4: Security & Governance (Priority Check)
-          if (t.includes('iam') || t.includes('kms') || t.includes('lake formation') || t.includes('secrets manager') || t.includes('cloudtrail') || t.includes('macie') || t.includes('encryption') || t.includes('security') || t.includes('permission') || t.includes('governance') || t.includes('vpc') || t.includes('pii') || t.includes('compliance')) {
-            domain = 4
-          }
-          // Domain 3: Data Operations and Support
-          else if (t.includes('step functions') || t.includes('emr') || t.includes('mwaa') || t.includes('airflow') || t.includes('cloudwatch') || t.includes('x-ray') || t.includes('eventbridge') || t.includes('sns') || t.includes('sqs') || t.includes('orchestration') || t.includes('monitoring') || t.includes('logging') || t.includes('debugging') || t.includes('troubleshooting')) {
-            domain = 3
-          }
-          // Domain 2: Data Store Management
-          else if (t.includes('redshift') || t.includes('s3') || t.includes('athena') || t.includes('dynamodb') || t.includes('opensearch') || t.includes('rds') || t.includes('aurora') || t.includes('storage') || t.includes('partition') || t.includes('nosql') || t.includes('deduplication')) {
-            domain = 2
-          }
-          // Domain 1: Data Ingestion and Transformation
-          else if (t.includes('glue') || t.includes('kinesis') || t.includes('lambda') || t.includes('dms') || t.includes('appflow') || t.includes('kafka') || t.includes('msk') || t.includes('flink') || t.includes('ingestion') || t.includes('etl') || t.includes('datasync') || t.includes('transfer')) {
-            domain = 1
-          }
-
-          return {
-            ...q,
-            domain,
-            explanation: q.explanation || `Correct answer for this ${q.topic} question.`
-          }
-        })
-
-        // 2. Group by domain
-        const byDomain = { 1: [], 2: [], 3: [], 4: [] }
-        mappedQuestions.forEach(q => {
-          if (byDomain[q.domain]) byDomain[q.domain].push(q)
-        })
-
-        // 3. Select based on weightage
-        // Domain 1: 34% (~22 q)
-        // Domain 2: 26% (~17 q)
-        // Domain 3: 22% (~14 q)
-        // Domain 4: 18% (~12 q)
-        const d1 = byDomain[1].sort(() => Math.random() - 0.5).slice(0, 22)
-        const d2 = byDomain[2].sort(() => Math.random() - 0.5).slice(0, 17)
-        const d3 = byDomain[3].sort(() => Math.random() - 0.5).slice(0, 14)
-        const d4 = byDomain[4].sort(() => Math.random() - 0.5).slice(0, 12)
-
-        selectedQuestions = [...d1, ...d2, ...d3, ...d4]
-          .sort(() => Math.random() - 0.5) // Final shuffle
-
-        setQuestions(selectedQuestions)
-        setTimeLeft(config.duration * 60)
-        setPhase('running')
-        return // Exit early
-      }
-
-      // Standard logic for other papers
-      let paperQuestions = []
-      switch (config.paper) {
-        case 'paper2':
-          paperQuestions = DEA_C01_PAPER_2_QUESTIONS
-          break
-        case 'paper3':
-          paperQuestions = DEA_C01_PAPER_3_QUESTIONS
-          break
-        case 'paper6':
-          paperQuestions = DEA_C01_PAPER_6_QUESTIONS
-          break
-        case 'paper4':
-          paperQuestions = DEA_C01_PAPER_4_QUESTIONS
-          break
-        case 'paper5':
-          paperQuestions = DEA_C01_PAPER_5_QUESTIONS
-          break
-        case 'paper8':
-          paperQuestions = DEA_C01_PAPER_8_QUESTIONS
-          break
-        case 'paper1':
-        default:
-          paperQuestions = DEA_C01_PRACTICE_QUESTIONS
-      }
-
-      // Map questions with domain information
-      selectedQuestions = paperQuestions.map(q => ({
-        ...q,
-        domain: q.topic?.includes('Glue') || q.topic?.includes('Kinesis') || q.topic?.includes('Lambda') ? 1 :
-          q.topic?.includes('Redshift') || q.topic?.includes('S3') || q.topic?.includes('Athena') ? 2 :
-            q.topic?.includes('Step Functions') || q.topic?.includes('EMR') ? 3 : 4,
-        explanation: q.explanation || `Correct answer for this ${q.topic} question.`
-      }))
-
-      selectedQuestions = selectedQuestions
-        .sort(() => Math.random() - 0.5)
-        .slice(0, config.questionCount)
-
-      setQuestions(selectedQuestions)
-      setTimeLeft(config.duration * 60)
-      setPhase('running')
-    } catch (error) {
-      console.error('Error loading exam:', error)
-    }
-  }
-
-  const selectAnswer = (questionIndex, optionIndex) => {
-    const question = questions[questionIndex]
-
-    if (question.type === 'multiple') {
-      const currentAnswers = answers[questionIndex] || []
-      if (currentAnswers.includes(optionIndex)) {
-        setAnswers({
-          ...answers,
-          [questionIndex]: currentAnswers.filter(a => a !== optionIndex)
-        })
-      } else if (currentAnswers.length < (question.selectCount || 2)) {
-        setAnswers({
-          ...answers,
-          [questionIndex]: [...currentAnswers, optionIndex]
-        })
-      }
-    } else {
-      setAnswers({
-        ...answers,
-        [questionIndex]: optionIndex
-      })
-    }
-  }
-
-  const toggleFlag = (index) => {
-    if (flagged.includes(index)) {
-      setFlagged(flagged.filter(i => i !== index))
-    } else {
-      setFlagged([...flagged, index])
-    }
-  }
-
-  const isCorrect = (questionIndex) => {
-    const question = questions[questionIndex]
-    const answer = answers[questionIndex]
-
-    if (question.type === 'multiple') {
-      if (!Array.isArray(answer)) return false
-      return question.correctAnswers.every(c => answer.includes(c)) &&
-        answer.every(a => question.correctAnswers.includes(a))
-    } else {
-      return answer === question.correctAnswer
-    }
-  }
-
-  const submitExam = async () => {
-    let correct = 0
-    let attempted = 0
-    const domainScores = { 1: { correct: 0, total: 0 }, 2: { correct: 0, total: 0 }, 3: { correct: 0, total: 0 }, 4: { correct: 0, total: 0 } }
-
-    questions.forEach((q, index) => {
-      domainScores[q.domain].total++
-
-      if (answers[index] !== undefined) {
-        attempted++
-        if (isCorrect(index)) {
-          correct++
-          domainScores[q.domain].correct++
-        }
-      }
-    })
-
-    const rawScore = (correct / questions.length) * 100
-    const scaledScore = Math.round(100 + (rawScore * 9))
-
-    const examResults = {
-      totalQuestions: questions.length,
-      attempted,
-      correct,
-      wrong: attempted - correct,
-      unanswered: questions.length - attempted,
-      rawScore: Math.round(rawScore),
-      scaledScore,
-      passed: scaledScore >= 720,
-      domainScores,
-      timeSpent: examConfig.duration * 60 - timeLeft,
-      examType: 'aws-dea',
-      completedAt: new Date().toISOString()
-    }
-
-    setResults(examResults)
-    setPhase('completed')
-
-    if (user && sessionId) {
-      try {
-        await updateDoc(doc(db, 'sessions', sessionId), {
-          ...examResults,
-          status: 'completed'
-        })
-
-        // Update AWS Leaderboard
-        const awsLeaderboardRef = doc(db, 'aws-leaderboard', user.uid)
-        const existing = await getDoc(awsLeaderboardRef)
-
-        if (existing.exists()) {
-          const currentData = existing.data()
-          await updateDoc(awsLeaderboardRef, {
-            bestScore: Math.max(currentData.bestScore || 0, scaledScore),
-            totalExams: (currentData.totalExams || 0) + 1,
-            passed: currentData.passed || scaledScore >= 720,
-            lastActive: new Date(),
-            userName: user.displayName,
-            photoURL: user.photoURL
-          })
-        } else {
-          await setDoc(awsLeaderboardRef, {
-            userId: user.uid,
-            userName: user.displayName,
-            photoURL: user.photoURL,
-            bestScore: scaledScore,
-            totalExams: 1,
-            passed: scaledScore >= 720,
-            lastActive: new Date()
-          })
-        }
-
-        // Update User Statistics (Dashboard)
-        const userRef = doc(db, 'users', user.uid)
-        await updateDoc(userRef, {
-          totalTests: increment(1),
-          totalQuestions: increment(questions.length),
-          totalCorrect: increment(correct),
-          lastActivity: serverTimestamp()
-        })
-
-        // Update Streak
-        await updateStreak(user.uid)
-      } catch (error) {
-        console.error('Error saving results:', error)
-      }
-    }
-  }
-
-  const formatTime = (seconds) => {
-    const mins = Math.floor(seconds / 60)
-    const secs = seconds % 60
-    return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
-  }
-
-  if (phase === 'loading') {
-    return (
-      <div className="min-h-screen flex items-center justify-center">
-        <div className="text-center">
-          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-primary-600 mx-auto mb-4" />
-          <p className="text-gray-600 dark:text-gray-400">Loading AWS Exam...</p>
-        </div>
-      </div>
-    )
-  }
-
-  if (phase === 'completed' && results) {
-    return (
-      <div className="max-w-4xl mx-auto px-4 py-8">
-        <div className="card text-center mb-8">
-          <Cloud className="w-16 h-16 mx-auto mb-4 text-orange-500" />
-          <h1 className="text-2xl font-bold mb-2 text-gray-900 dark:text-white">
-            AWS Data Engineer Associate - Results
-          </h1>
-
-          <div className={`p-6 rounded-xl mb-6 ${results.passed
-            ? 'bg-green-50 dark:bg-green-900/30 border-2 border-green-500'
-            : 'bg-red-50 dark:bg-red-900/30 border-2 border-red-500'
-            }`}>
-            <div className="text-5xl font-bold mb-2" style={{
-              color: results.passed ? '#10b981' : '#ef4444'
-            }}>
-              {results.scaledScore}/1000
-            </div>
-            <p className={`text-lg font-semibold ${results.passed ? 'text-green-700 dark:text-green-300' : 'text-red-700 dark:text-red-300'
-              }`}>
-              {results.passed ? '­ƒÄë PASSED! Congratulations!' : 'ÔØî Not Passed - Keep Practicing!'}
-            </p>
-            <p className="text-sm text-gray-600 dark:text-gray-400 mt-1">
-              Passing Score: 720/1000 | Your Raw Score: {results.rawScore}%
-            </p>
-          </div>
-
-          <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mb-6">
-            <div className="p-4 bg-gray-50 dark:bg-gray-700 rounded-lg">
-              <p className="text-2xl font-bold text-gray-900 dark:text-white">{results.totalQuestions}</p>
-              <p className="text-sm text-gray-500 dark:text-gray-400">Total</p>
-            </div>
-            <div className="p-4 bg-green-50 dark:bg-green-900/30 rounded-lg">
-              <p className="text-2xl font-bold text-green-600 dark:text-green-400">{results.correct}</p>
-              <p className="text-sm text-gray-500 dark:text-gray-400">Correct</p>
-            </div>
-            <div className="p-4 bg-red-50 dark:bg-red-900/30 rounded-lg">
-              <p className="text-2xl font-bold text-red-600 dark:text-red-400">{results.wrong}</p>
-              <p className="text-sm text-gray-500 dark:text-gray-400">Wrong</p>
-            </div>
-            <div className="p-4 bg-gray-50 dark:bg-gray-700 rounded-lg">
-              <p className="text-2xl font-bold text-gray-600 dark:text-gray-300">{results.unanswered}</p>
-              <p className="text-sm text-gray-500 dark:text-gray-400">Unanswered</p>
-            </div>
-          </div>
-
-          <div className="mb-6">
-            <h3 className="font-semibold text-gray-900 dark:text-white mb-4">Domain Performance</h3>
-            <div className="space-y-3">
-              {[
-                { id: 1, name: 'Data Ingestion & Transformation', weight: '34%' },
-                { id: 2, name: 'Data Store Management', weight: '26%' },
-                { id: 3, name: 'Data Operations & Support', weight: '22%' },
-                { id: 4, name: 'Data Security & Governance', weight: '18%' }
-              ].map(domain => {
-                const score = results.domainScores[domain.id]
-                const percentage = score.total > 0 ? Math.round((score.correct / score.total) * 100) : 0
-                return (
-                  <div key={domain.id} className="text-left">
-                    <div className="flex justify-between text-sm mb-1">
-                      <span className="text-gray-700 dark:text-gray-300">
-                        Domain {domain.id}: {domain.name}
-                      </span>
-                      <span className="font-medium text-gray-900 dark:text-white">
-                        {score.correct}/{score.total} ({percentage}%)
-                      </span>
-                    </div>
-                    <div className="w-full bg-gray-200 dark:bg-gray-700 rounded-full h-2">
-                      <div
-                        className={`h-2 rounded-full ${percentage >= 70 ? 'bg-green-500' : percentage >= 50 ? 'bg-yellow-500' : 'bg-red-500'
-                          }`}
-                        style={{ width: `${percentage}%` }}
-                      />
-                    </div>
-                  </div>
-                )
-              })}
-            </div>
-          </div>
-
-          <div className="flex gap-4">
-            <button
-              onClick={() => setPhase('review')}
-              className="flex-1 btn-secondary"
-            >
-              Review Answers
-            </button>
-            <button
-              onClick={() => navigate('/aws-certification')}
-              className="flex-1 btn-primary"
-            >
-              Practice Again
-            </button>
-          </div>
-        </div>
-      </div>
-    )
-  }
-
-  const currentQuestion = questions[currentIndex]
-  const isReviewMode = examConfig?.mode === 'review' || phase === 'review'
-
-  if (!currentQuestion) {
-    return (
-      <div className="min-h-screen flex items-center justify-center">
-        <div className="text-center">
-          <p className="text-gray-600 dark:text-gray-400">No questions available</p>
-          <button onClick={() => navigate('/aws-certification')} className="btn-primary mt-4">
-            Back to AWS Certification
-          </button>
-        </div>
-      </div>
-    )
-  }
-
-  return (
-    <div className="max-w-5xl mx-auto px-4 py-4">
-      <div className="flex items-center justify-between mb-4">
-        <div className="flex items-center gap-2">
-          <Cloud className="w-6 h-6 text-orange-500" />
-          <span className="font-bold text-gray-900 dark:text-white">AWS DEA Practice</span>
-        </div>
-        {!isReviewMode && timeLeft > 0 && (
-          <div className={`flex items-center gap-2 px-4 py-2 rounded-lg font-mono text-lg font-bold ${timeLeft < 300 ? 'bg-red-100 dark:bg-red-900/50 text-red-600 dark:text-red-400 animate-pulse' : 'bg-gray-100 dark:bg-gray-700 text-gray-900 dark:text-white'
-            }`}>
-            <Clock className="w-5 h-5" />
-            {formatTime(timeLeft)}
-          </div>
-        )}
-        {isReviewMode && (
-          <span className="px-3 py-1 bg-blue-100 dark:bg-blue-900/30 text-blue-700 dark:text-blue-300 rounded-lg text-sm font-medium">
-            Review Mode
-          </span>
-        )}
-      </div>
-
-      <div className="flex gap-4">
-        <div className="flex-1">
-          <div className="card">
-            <div className="flex items-center justify-between mb-4">
-              <div className="flex items-center gap-2">
-                <span className="text-sm text-gray-500 dark:text-gray-400">
-                  Question {currentIndex + 1} of {questions.length}
-                </span>
-                <span className="text-xs px-2 py-1 bg-orange-100 dark:bg-orange-900/30 text-orange-700 dark:text-orange-300 rounded">
-                  Domain {currentQuestion?.domain}
-                </span>
-                {currentQuestion?.type === 'multiple' && (
-                  <span className="text-xs px-2 py-1 bg-purple-100 dark:bg-purple-900/30 text-purple-700 dark:text-purple-300 rounded">
-                    Select {currentQuestion.selectCount}
-                  </span>
-                )}
-              </div>
-              <button
-                onClick={() => toggleFlag(currentIndex)}
-                className={`p-2 rounded ${flagged.includes(currentIndex)
-                  ? 'bg-orange-100 dark:bg-orange-900/50 text-orange-600 dark:text-orange-400'
-                  : 'bg-gray-100 dark:bg-gray-700 text-gray-600 dark:text-gray-400'
-                  }`}
-              >
-                <Flag className="w-4 h-4" />
-              </button>
-            </div>
-
-            <h3 className="text-lg font-medium mb-6 text-gray-900 dark:text-white">
-              {currentQuestion?.question}
-            </h3>
-
-
-            <div className="space-y-3">
-              {currentQuestion?.options?.map((option, index) => {
-                const isSelected = currentQuestion.type === 'multiple'
-                  ? (answers[currentIndex] || []).includes(index)
-                  : answers[currentIndex] === index
-                const isCorrectOption = currentQuestion.type === 'multiple'
-                  ? (currentQuestion.correctAnswers || []).includes(index)
-                  : currentQuestion.correctAnswer === index
-                const showResult = isReviewMode && answers[currentIndex] !== undefined
-
-                return (
-                  <label
-                    key={index}
-                    className={`w-full p-4 flex items-start gap-3 rounded-lg border-2 transition-all cursor-pointer ${showResult
-                      ? isCorrectOption
-                        ? 'border-green-500 bg-green-50 dark:bg-green-900/30'
-                        : isSelected
-                          ? 'border-red-500 bg-red-50 dark:bg-red-900/30'
-                          : 'border-gray-200 dark:border-gray-600 bg-white dark:bg-gray-800'
-                      : isSelected
-                        ? 'border-primary-500 bg-primary-50 dark:bg-primary-900/30'
-                        : 'border-gray-200 dark:border-gray-600 hover:border-gray-300 dark:hover:border-gray-500 bg-white dark:bg-gray-800'
-                      } text-gray-900 dark:text-white ${isReviewMode ? 'cursor-not-allowed' : ''}`}
-                  >
-                    <input
-                      type={currentQuestion.type === 'multiple' ? 'checkbox' : 'radio'}
-                      name={`question-${currentIndex}`}
-                      checked={isSelected}
-                      onChange={() => !isReviewMode && selectAnswer(currentIndex, index)}
-                      disabled={isReviewMode}
-                      className="mt-1 w-4 h-4 text-primary-600 focus:ring-primary-500 border-gray-300 rounded"
-                    />
-                    <div className="flex-1">
-                      <div className="flex items-start gap-2">
-                        <span className={`flex-shrink-0 w-6 h-6 rounded-full flex items-center justify-center text-sm font-medium ${showResult
-                          ? isCorrectOption
-                            ? 'bg-green-500 text-white'
-                            : isSelected
-                              ? 'bg-red-500 text-white'
-                              : 'bg-gray-200 dark:bg-gray-600 text-gray-600 dark:text-gray-300'
-                          : isSelected
-                            ? 'bg-primary-500 text-white'
-                            : 'bg-gray-200 dark:bg-gray-600 text-gray-600 dark:text-gray-300'
-                          }`}>
-                          {showResult ? (
-                            isCorrectOption ? <Check className="w-4 h-4" /> : isSelected ? <X className="w-4 h-4" /> : String.fromCharCode(65 + index)
-                          ) : (
-                            String.fromCharCode(65 + index)
-                          )}
-                        </span>
-                        <span>{option}</span>
-                      </div>
-                    </div>
-                  </label>
-                )
-              })}
-            </div>
-
-            {isReviewMode && (
-              <div className="mt-4 p-4 bg-blue-50 dark:bg-blue-900/30 rounded-lg">
-                <h4 className="font-semibold text-blue-800 dark:text-blue-300 mb-2 flex items-center gap-2">
-                  <AlertCircle className="w-4 h-4" />
-                  Explanation
-                </h4>
-                <p className="text-blue-700 dark:text-blue-200 text-sm">
-                  {currentQuestion?.explanation}
-                </p>
-              </div>
-            )}
-
-            <div className="flex items-center justify-between mt-6">
-              <button
-                onClick={() => setCurrentIndex(Math.max(0, currentIndex - 1))}
-                disabled={currentIndex === 0}
-                className="flex items-center gap-2 px-4 py-2 bg-gray-100 dark:bg-gray-700 text-gray-700 dark:text-white rounded-lg disabled:opacity-50"
-              >
-                <ChevronLeft className="w-4 h-4" />
-                Previous
-              </button>
-
-              {currentIndex < questions.length - 1 ? (
-                <button
-                  onClick={() => setCurrentIndex(currentIndex + 1)}
-                  className="flex items-center gap-2 btn-primary"
-                >
-                  Next
-                  <ChevronRight className="w-4 h-4" />
-                </button>
-              ) : (
-                <button
-                  onClick={phase === 'review' ? () => navigate('/aws-certification') : submitExam}
-                  className="btn-primary bg-green-600 hover:bg-green-700"
-                >
-                  {phase === 'review' ? 'Back to Practice' : 'Submit Exam'}
-                </button>
-              )}
-            </div>
-          </div>
-        </div>
-
-        <div className="w-64 hidden lg:block">
-          <div className="card sticky top-4">
-            <h3 className="font-semibold mb-3 text-gray-900 dark:text-white">Question Navigator</h3>
-            <div className="grid grid-cols-5 gap-2 mb-4">
-              {questions.map((_, index) => {
-                const isAnswered = answers[index] !== undefined
-                const isCurrent = index === currentIndex
-                const isFlagged = flagged.includes(index)
-                const isCorrectAnswer = isReviewMode && isAnswered && isCorrect(index)
-                const isWrongAnswer = isReviewMode && isAnswered && !isCorrect(index)
-
-                return (
-                  <button
-                    key={index}
-                    onClick={() => setCurrentIndex(index)}
-                    className={`w-10 h-10 rounded-lg font-medium text-sm ${isCurrent
-                      ? 'bg-primary-600 text-white'
-                      : isReviewMode && isCorrectAnswer
-                        ? 'bg-green-100 dark:bg-green-900/50 text-green-700 dark:text-green-400 border-2 border-green-500'
-                        : isReviewMode && isWrongAnswer
-                          ? 'bg-red-100 dark:bg-red-900/50 text-red-700 dark:text-red-400 border-2 border-red-500'
-                          : isAnswered
-                            ? 'bg-green-100 dark:bg-green-900/50 text-green-700 dark:text-green-400'
-                            : isFlagged
-                              ? 'bg-orange-100 dark:bg-orange-900/50 text-orange-700 dark:text-orange-400'
-                              : 'bg-gray-100 dark:bg-gray-700 text-gray-700 dark:text-gray-300'
-                      }`}
-                  >
-                    {index + 1}
-                  </button>
-                )
-              })}
-            </div>
-
-            <div className="text-xs space-y-1 border-t dark:border-gray-700 pt-3 text-gray-600 dark:text-gray-400">
-              <div className="flex items-center gap-2">
-                <div className="w-4 h-4 bg-green-100 dark:bg-green-900/50 rounded" />
-                <span>Answered ({Object.keys(answers).length})</span>
-              </div>
-              <div className="flex items-center gap-2">
-                <div className="w-4 h-4 bg-orange-100 dark:bg-orange-900/50 rounded" />
-                <span>Flagged ({flagged.length})</span>
-              </div>
-              <div className="flex items-center gap-2">
-                <div className="w-4 h-4 bg-gray-100 dark:bg-gray-700 rounded" />
-                <span>Not Visited</span>
-              </div>
-            </div>
-
-            {!isReviewMode && (
-              <button
-                onClick={submitExam}
-                className="btn-primary w-full mt-4 bg-green-600 hover:bg-green-700"
-              >
-                Submit Exam
-              </button>
-            )}
-          </div>
-        </div>
-      </div>
-    </div>
-  )
-}
+import { useState, useEffect } from 'react'
+import { useParams, useLocation, useNavigate } from 'react-router-dom'
+import { useAuth } from '../contexts/AuthContext'
+import {
+  doc,
+  getDoc,
+  setDoc,
+  updateDoc,
+  collection,
+  addDoc,
+  serverTimestamp,
+  increment,
+  query,
+  where,
+  getDocs
+} from 'firebase/firestore'
+import { db } from '../config/firebase'
+import {
+  Clock, Flag, ChevronLeft, ChevronRight, Check, X,
+  AlertCircle, CheckCircle, ArrowLeft, Cloud
+} from 'lucide-react'
+import { updateStreak } from '../services/learningService'
+import { DEA_C01_PRACTICE_QUESTIONS } from '../data/deaC01PracticeQuestions'
+import { DEA_C01_PAPER_2_QUESTIONS } from '../data/deaC01Paper2Questions'
+import { DEA_C01_PAPER_3_QUESTIONS } from '../data/deaC01Paper3Questions'
+import { DEA_C01_PAPER_6_QUESTIONS } from '../data/deaC01Paper6Questions'
+import { DEA_C01_PAPER_4_QUESTIONS } from '../data/deaC01Paper4Questions'
+import { DEA_C01_PAPER_5_QUESTIONS } from '../data/deaC01Paper5Questions'
+import { DEA_C01_PAPER_8_QUESTIONS } from '../data/deaC01Paper8Questions'
+
+// AWS DEA-C01 Question Bank - 69 Scenario-Based Questions (matches real exam)
+const AWS_QUESTIONS = {
+  // Domain 1: Data Ingestion and Transformation (34% - 24 questions)
+  1: [
+    {
+      id: 'd1_1',
+      question: "A company needs to ingest streaming data from IoT sensors and store it in Amazon S3 with near real-time delivery. The data should be automatically converted to Parquet format. Which solution meets these requirements with the LEAST operational overhead?",
+      options: [
+        "Use Amazon Kinesis Data Streams with AWS Lambda to convert and write to S3",
+        "Use Amazon Kinesis Data Firehose with record format conversion enabled",
+        "Use Amazon MSK (Managed Streaming for Kafka) with Kafka Connect to S3",
+        "Use AWS Glue Streaming ETL job to process and write to S3"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Amazon Kinesis Data Firehose provides the LEAST operational overhead as it's a fully managed service that can automatically convert data formats (including to Parquet) and deliver to S3. It requires no code and handles scaling automatically.",
+      domain: 1,
+      topic: "Streaming Ingestion",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_2',
+      question: "A data engineer needs to extract data from an on-premises Oracle database and load it into Amazon Redshift. The initial load is 10 TB and ongoing changes must be captured continuously. Which approach is MOST efficient?",
+      options: [
+        "Use AWS Database Migration Service (DMS) with full load and CDC",
+        "Export data to CSV files, upload to S3, and use COPY command",
+        "Use AWS Glue JDBC connection for initial and incremental loads",
+        "Use Amazon AppFlow to connect Oracle and Redshift"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "AWS DMS with full load and Change Data Capture (CDC) is the most efficient solution. It handles the initial bulk load and then captures ongoing changes from the Oracle redo logs, providing continuous replication to Redshift.",
+      domain: 1,
+      topic: "Database Migration",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_3',
+      question: "A company uses AWS Glue for ETL jobs. The jobs are failing because of schema changes in the source data. What should the data engineer implement to handle schema evolution? (Select TWO)",
+      options: [
+        "Enable the AWS Glue Schema Registry",
+        "Use DynamicFrame instead of DataFrame in the Glue job",
+        "Increase the memory allocation for the Glue job",
+        "Configure the Glue crawler to update table schema on each run",
+        "Use Amazon Athena instead of AWS Glue"
+      ],
+      correctAnswer: null,
+      correctAnswers: [1, 3],
+      type: "multiple",
+      selectCount: 2,
+      explanation: "DynamicFrame in AWS Glue can handle schema inconsistencies through features like 'choice' type handling. Configuring the Glue crawler to update the schema ensures the Data Catalog reflects the latest source schema.",
+      domain: 1,
+      topic: "Schema Evolution",
+      difficulty: "hard"
+    },
+    {
+      id: 'd1_4',
+      question: "An AWS Glue ETL job processes 500 GB of JSON files daily. The job is taking 4 hours to complete. Which optimization will MOST likely reduce the job duration?",
+      options: [
+        "Increase the number of DPUs (Data Processing Units)",
+        "Convert source files to Parquet format before processing",
+        "Use AWS Glue bookmarks to process only new data",
+        "Switch from Python to Scala for the ETL script"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Converting JSON to Parquet before processing will significantly improve performance. Parquet is columnar, compressed, and supports predicate pushdown. Reading 500 GB of JSON is much slower than reading optimized Parquet files.",
+      domain: 1,
+      topic: "Performance Optimization",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_5',
+      question: "A real-time analytics application requires sub-second latency for data ingestion. The data comes from mobile applications at a rate of 100,000 events per second during peak hours. Which architecture should be used?",
+      options: [
+        "Amazon Kinesis Data Firehose  Amazon S3  Amazon Athena",
+        "Amazon Kinesis Data Streams  AWS Lambda  Amazon DynamoDB",
+        "Amazon SQS  AWS Lambda  Amazon RDS",
+        "Amazon MSK  Amazon EMR  Amazon Redshift"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "For sub-second latency with 100K events/second, Kinesis Data Streams to Lambda to DynamoDB provides real-time processing. DynamoDB offers single-digit millisecond latency. Firehose has 60-second minimum buffering.",
+      domain: 1,
+      topic: "Real-time Processing",
+      difficulty: "hard"
+    },
+    {
+      id: 'd1_6',
+      question: "A data pipeline uses AWS Step Functions to orchestrate multiple AWS Glue jobs. One job frequently fails due to source system unavailability. How should the data engineer implement resilient error handling?",
+      options: [
+        "Add a Catch block with exponential backoff retry in Step Functions",
+        "Increase the timeout for the Glue job",
+        "Use Amazon EventBridge to schedule retries",
+        "Implement error handling in the Glue job code only"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "Step Functions supports native Retry with exponential backoff and Catch blocks for error handling. This provides resilient orchestration at the workflow level without modifying individual job code.",
+      domain: 1,
+      topic: "Pipeline Orchestration",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_7',
+      question: "A company needs to transform semi-structured JSON data with nested arrays into a flattened relational format for analysis. Which AWS Glue feature should be used?",
+      options: [
+        "Glue Data Quality",
+        "Relationalize transform",
+        "Glue Elastic Views",
+        "ResolveChoice transform"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "The Relationalize transform in AWS Glue converts nested JSON/semi-structured data into a set of flat tables that can be easily queried with standard SQL.",
+      domain: 1,
+      topic: "Data Transformation",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_8',
+      question: "A media company receives video metadata files in various formats (JSON, XML, CSV) from different content providers. The data must be normalized and stored in a consistent schema. Which approach provides the MOST flexibility?",
+      options: [
+        "Create separate Glue crawlers for each format",
+        "Use AWS Glue classifiers with custom patterns",
+        "Build custom Lambda functions for each format",
+        "Use Amazon Athena with different SerDe configurations"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "AWS Glue classifiers with custom patterns provide the most flexibility for handling various file formats. They can automatically detect and parse different formats, then normalize the data to a consistent schema.",
+      domain: 1,
+      topic: "Data Normalization",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_9',
+      question: "A financial services company needs to process credit card transactions in real-time to detect fraud. The system must handle 50,000 transactions per second with less than 100ms latency. Which architecture is MOST appropriate?",
+      options: [
+        "Kinesis Data Streams with enhanced fan-out consumers",
+        "Kinesis Data Firehose with Lambda transformation",
+        "Amazon SQS FIFO with Lambda",
+        "Amazon MSK with consumer groups"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "Kinesis Data Streams with enhanced fan-out provides dedicated 2 MB/s throughput per consumer with ~70ms propagation delay. This is ideal for real-time fraud detection requiring low latency at high throughput.",
+      domain: 1,
+      topic: "Real-time Processing",
+      difficulty: "hard"
+    },
+    {
+      id: 'd1_10',
+      question: "A data engineer needs to migrate data from Amazon RDS MySQL to Amazon Aurora PostgreSQL. The migration must minimize downtime. Which approach should be used?",
+      options: [
+        "AWS DMS with Schema Conversion Tool (SCT)",
+        "AWS Glue with JDBC connections",
+        "Export/Import using mysqldump and pg_restore",
+        "AWS DataSync between the databases"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "AWS DMS with Schema Conversion Tool (SCT) is designed for heterogeneous database migrations. SCT converts the schema while DMS handles continuous data replication with minimal downtime.",
+      domain: 1,
+      topic: "Database Migration",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_11',
+      question: "A retail company wants to sync data from Salesforce to Amazon S3 on a scheduled basis. The solution should require minimal coding. Which service should be used?",
+      options: [
+        "AWS Glue with custom connectors",
+        "Amazon AppFlow",
+        "AWS Lambda with Salesforce SDK",
+        "Amazon EventBridge with API destinations"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Amazon AppFlow is a fully managed integration service that enables secure data transfer between SaaS applications like Salesforce and AWS services like S3, with no coding required.",
+      domain: 1,
+      topic: "SaaS Integration",
+      difficulty: "easy"
+    },
+    {
+      id: 'd1_12',
+      question: "An e-commerce platform generates clickstream data that needs to be enriched with product catalog information before storage. The enrichment should happen in near real-time. Which solution is MOST efficient?",
+      options: [
+        "Kinesis Data Streams with Lambda enrichment using DynamoDB lookups",
+        "Kinesis Data Firehose with Glue transformation",
+        "S3 event triggers with Step Functions",
+        "EMR Spark Streaming with broadcast variables"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "Kinesis Data Streams with Lambda enrichment using DynamoDB lookups provides near real-time enrichment with single-digit millisecond DynamoDB access times.",
+      domain: 1,
+      topic: "Data Enrichment",
+      difficulty: "hard"
+    },
+    {
+      id: 'd1_13',
+      question: "A healthcare company needs to ingest HL7 FHIR formatted patient data from multiple hospital systems. The data arrives via REST APIs and must be transformed to a standard schema. Which approach minimizes development effort?",
+      options: [
+        "AWS HealthLake with integrated data transformation",
+        "API Gateway with Lambda and custom transformation",
+        "AWS Glue with custom ETL scripts",
+        "Amazon Kinesis with Lambda consumers"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "AWS HealthLake is specifically designed for healthcare data in FHIR format. It provides automatic data transformation, storage, and analytics capabilities with minimal development effort.",
+      domain: 1,
+      topic: "Healthcare Data Ingestion",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_14',
+      question: "A gaming company processes 1 TB of player event data daily. The data arrives continuously and must be available for analysis within 15 minutes. Which ingestion pattern is MOST cost-effective?",
+      options: [
+        "Kinesis Data Streams with Lambda to S3",
+        "Kinesis Data Firehose with 60-second buffering",
+        "Direct S3 PutObject from game servers",
+        "Amazon MSK with S3 Sink Connector"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Kinesis Data Firehose with 60-second buffering is the most cost-effective for this use case. It's fully managed, automatically scales, and the 60-second buffer easily meets the 15-minute availability requirement.",
+      domain: 1,
+      topic: "Cost-Effective Ingestion",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_15',
+      question: "A data engineer needs to deduplicate streaming records before storing them. Records have a unique transaction_id and duplicates can arrive within a 5-minute window. Which approach is MOST efficient?",
+      options: [
+        "Use Kinesis Data Analytics with a 5-minute tumbling window and DISTINCT",
+        "Lambda with DynamoDB for deduplication tracking",
+        "Kinesis Data Streams with Kinesis Client Library (KCL) checkpointing",
+        "Store all records in S3 and deduplicate with Athena"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "Kinesis Data Analytics with SQL can efficiently deduplicate records within a time window using GROUP BY and aggregation. This provides real-time deduplication without managing additional infrastructure.",
+      domain: 1,
+      topic: "Stream Deduplication",
+      difficulty: "hard"
+    },
+    {
+      id: 'd1_16',
+      question: "A company is migrating a legacy ETL system to AWS Glue. The existing jobs use complex stored procedures in Oracle. How should the data engineer approach this migration?",
+      options: [
+        "Rewrite all logic in PySpark for AWS Glue",
+        "Use AWS Glue with Oracle JDBC and call stored procedures",
+        "Convert procedures using AWS SCT, then implement in Glue",
+        "Keep stored procedures and use AWS DMS for data movement"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "AWS Schema Conversion Tool (SCT) can convert Oracle stored procedures to equivalent AWS Glue ETL code (PySpark/Scala), reducing manual rewriting effort while ensuring logic is properly migrated.",
+      domain: 1,
+      topic: "ETL Migration",
+      difficulty: "hard"
+    },
+    {
+      id: 'd1_17',
+      question: "A logistics company needs to process GPS coordinates from 10,000 delivery vehicles in real-time. Each vehicle sends location updates every 5 seconds. The data must be stored for route optimization analysis. Which architecture handles this efficiently?",
+      options: [
+        "IoT Core  IoT Rules  Kinesis Data Firehose  S3",
+        "API Gateway  Lambda  DynamoDB",
+        "IoT Core  IoT Analytics  QuickSight",
+        "Direct MQTT to EC2 instances with custom processing"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "IoT Core with IoT Rules to Kinesis Data Firehose to S3 efficiently handles high-volume IoT data ingestion. IoT Core manages device connections while Firehose handles reliable delivery to S3.",
+      domain: 1,
+      topic: "IoT Data Ingestion",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_18',
+      question: "A data pipeline must process files that arrive in S3 in any order but must be processed in sequence based on a timestamp in the filename. Which approach ensures correct ordering?",
+      options: [
+        "Use S3 event notifications to trigger Lambda immediately",
+        "Use AWS Glue workflow with job bookmarks",
+        "Implement a Step Functions workflow with file ordering logic",
+        "Use S3 Batch Operations for sequential processing"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "Step Functions can implement custom ordering logic to sort files by timestamp and process them sequentially. This provides explicit control over processing order regardless of arrival time.",
+      domain: 1,
+      topic: "Ordered Processing",
+      difficulty: "hard"
+    },
+    {
+      id: 'd1_19',
+      question: "A data engineer needs to incrementally load data from a source system that doesn't support change data capture. The source table has 100 million rows with a last_modified timestamp column. Which approach is MOST efficient?",
+      options: [
+        "Full table extraction daily",
+        "AWS Glue job with bookmark on last_modified column",
+        "AWS DMS with full load only",
+        "Athena CTAS with date filter"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "AWS Glue job bookmarks can track the last processed value of the last_modified column, enabling efficient incremental loads without full table scans on each run.",
+      domain: 1,
+      topic: "Incremental Loading",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_20',
+      question: "A company uses multiple AWS accounts for different departments. Data from all accounts must be consolidated in a central data lake. Which approach simplifies cross-account data ingestion?",
+      options: [
+        "Set up VPC peering between all accounts",
+        "Use S3 replication with cross-account bucket policies",
+        "Configure AWS RAM to share S3 buckets",
+        "Build custom Lambda functions in each account"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "S3 replication with cross-account bucket policies is the most straightforward approach. S3 replication rules can automatically copy objects to a central bucket with proper IAM permissions.",
+      domain: 1,
+      topic: "Cross-Account Ingestion",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_21',
+      question: "An AWS Glue job reads from a JDBC source and writes to S3 in Parquet format. The job is slow due to the JDBC connection being a bottleneck. How can the data engineer improve performance? (Select TWO)",
+      options: [
+        "Enable parallel reads using hashfield or hashpartitions",
+        "Increase the number of Glue DPUs",
+        "Use pushdown predicates to filter at the source",
+        "Switch to Glue version 1.0",
+        "Enable Glue job metrics"
+      ],
+      correctAnswer: null,
+      correctAnswers: [0, 2],
+      type: "multiple",
+      selectCount: 2,
+      explanation: "Enabling parallel reads (hashfield/hashpartitions) and pushdown predicates reduces JDBC bottleneck. Parallel reads split the table across multiple connections, and pushdown predicates minimize data transferred from source.",
+      domain: 1,
+      topic: "JDBC Optimization",
+      difficulty: "hard"
+    },
+    {
+      id: 'd1_22',
+      question: "A streaming application needs exactly-once semantics when writing to Amazon S3 from Kinesis Data Streams. Which approach guarantees this?",
+      options: [
+        "Use Kinesis Data Firehose with S3 destination",
+        "Implement idempotent writes in Lambda with DynamoDB tracking",
+        "Use Kinesis Data Analytics for Flink with exactly-once checkpointing",
+        "Configure Kinesis enhanced fan-out consumers"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "Kinesis Data Analytics for Apache Flink provides exactly-once processing semantics through its checkpointing mechanism, ensuring no data loss or duplication when writing to sinks like S3.",
+      domain: 1,
+      topic: "Exactly-Once Processing",
+      difficulty: "hard"
+    },
+    {
+      id: 'd1_23',
+      question: "A data engineer needs to validate incoming data quality before loading to the data warehouse. Records failing validation should be sent to a dead-letter queue for investigation. Which service combination achieves this?",
+      options: [
+        "AWS Glue with Data Quality rules and SQS DLQ",
+        "Lambda with custom validation and SNS notifications",
+        "Kinesis Data Analytics with error output stream",
+        "Step Functions with Choice states and SQS"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "AWS Glue Data Quality allows defining validation rules (DQDL) and can route failed records to an SQS dead-letter queue, providing an integrated solution for data quality validation.",
+      domain: 1,
+      topic: "Data Quality",
+      difficulty: "medium"
+    },
+    {
+      id: 'd1_24',
+      question: "A company receives data files encrypted with customer-provided keys. The data must be re-encrypted with AWS-managed keys after ingestion. Which approach is MOST secure?",
+      options: [
+        "Decrypt in Lambda, then upload to S3 with SSE-KMS",
+        "Use S3 Batch Operations with decryption and re-encryption",
+        "Transfer via AWS Transfer Family with post-processing Lambda",
+        "Use AWS Glue with temporary decryption in memory"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "AWS Transfer Family provides secure file transfer with automatic integration to S3. Post-processing Lambda can re-encrypt files with KMS, keeping plaintext data only in Lambda's secure execution environment.",
+      domain: 1,
+      topic: "Encryption Handling",
+      difficulty: "hard"
+    }
+  ],
+
+  // Domain 2: Data Store Management (26% - 18 questions)
+  2: [
+    {
+      id: 'd2_1',
+      question: "A data lake on Amazon S3 contains 50 TB of data. Users query this data using Amazon Athena but report slow performance. The data is stored in CSV format with no partitioning. Which optimization will provide the GREATEST performance improvement?",
+      options: [
+        "Enable S3 Transfer Acceleration",
+        "Convert data to Parquet format and implement partitioning",
+        "Increase Athena query timeout settings",
+        "Move data to Amazon EFS for faster access"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Converting to Parquet (columnar, compressed) and implementing partitioning will dramatically improve Athena query performance. Parquet enables column pruning and compression, while partitioning allows Athena to scan only relevant data partitions.",
+      domain: 2,
+      topic: "Query Optimization",
+      difficulty: "medium"
+    },
+    {
+      id: 'd2_2',
+      question: "A company stores transaction data in Amazon Redshift. Query performance has degraded over time. Analysis shows that the distribution style is causing data skew. The main table has a transaction_id column and a customer_id column. Queries frequently join on customer_id. What should be done?",
+      options: [
+        "Change the distribution style to EVEN",
+        "Change the distribution key to customer_id",
+        "Add a sort key on transaction_id",
+        "Increase the number of nodes in the cluster"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Changing the distribution key to customer_id will collocate data for the frequently used join column, reducing data movement during queries. This directly addresses the data skew issue.",
+      domain: 2,
+      topic: "Redshift Optimization",
+      difficulty: "hard"
+    },
+    {
+      id: 'd2_3',
+      question: "A data engineer needs to design a DynamoDB table for a gaming application. The table will store player sessions with access patterns: 1) Get all sessions for a player, 2) Get sessions by game type for a player, 3) Get sessions within a date range for a player. What is the optimal key design?",
+      options: [
+        "Partition key: session_id",
+        "Partition key: player_id, Sort key: game_type#session_date",
+        "Partition key: player_id, Sort key: session_date, GSI on game_type",
+        "Partition key: game_type, Sort key: player_id"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Using player_id as partition key with a composite sort key (game_type#session_date) supports all three access patterns. Query on player_id gets all sessions, begins_with on sort key filters by game_type.",
+      domain: 2,
+      topic: "DynamoDB Design",
+      difficulty: "hard"
+    },
+    {
+      id: 'd2_4',
+      question: "An organization needs to store 100 TB of log data in S3. The data is queried infrequently (once per month) but must be available within 12 hours when needed. Which S3 storage class is MOST cost-effective?",
+      options: [
+        "S3 Standard",
+        "S3 Intelligent-Tiering",
+        "S3 Glacier Flexible Retrieval",
+        "S3 Glacier Deep Archive"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "S3 Glacier Flexible Retrieval is most cost-effective for infrequently accessed data needing retrieval within 3-12 hours. It's significantly cheaper than Standard for this access pattern.",
+      domain: 2,
+      topic: "S3 Storage Classes",
+      difficulty: "medium"
+    },
+    {
+      id: 'd2_5',
+      question: "A company wants to build a data lake with: centralized data catalog, fine-grained access control at column level, and automatic schema discovery. Which AWS services should be used? (Select TWO)",
+      options: [
+        "AWS Lake Formation",
+        "Amazon Macie",
+        "AWS Glue Data Catalog",
+        "Amazon Redshift Spectrum",
+        "AWS Config"
+      ],
+      correctAnswer: null,
+      correctAnswers: [0, 2],
+      type: "multiple",
+      selectCount: 2,
+      explanation: "AWS Lake Formation provides fine-grained access control (column-level) and integrates with the Glue Data Catalog for centralized metadata management. Glue Crawlers provide automatic schema discovery.",
+      domain: 2,
+      topic: "Data Lake Architecture",
+      difficulty: "medium"
+    },
+    {
+      id: 'd2_6',
+      question: "A Redshift cluster uses RA3 nodes. The data warehouse team wants to share data with another AWS account without copying the data. What feature should they use?",
+      options: [
+        "Redshift Spectrum",
+        "Redshift Data Sharing",
+        "AWS Data Exchange",
+        "S3 Cross-Account Access"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Redshift Data Sharing allows sharing live data between Redshift clusters across AWS accounts without physically copying the data. This is a native Redshift feature for RA3 nodes.",
+      domain: 2,
+      topic: "Data Sharing",
+      difficulty: "medium"
+    },
+    {
+      id: 'd2_7',
+      question: "A data warehouse query that previously took 10 seconds now takes 2 minutes. The table hasn't changed in size, but maintenance hasn't been run recently. Which Redshift maintenance task should be performed first?",
+      options: [
+        "VACUUM to reclaim space and resort rows",
+        "ANALYZE to update statistics",
+        "Resize the cluster",
+        "Modify the distribution key"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "ANALYZE updates table statistics that the query planner uses. Stale statistics cause poor query plans. This is the most likely cause when table size hasn't changed but performance degraded.",
+      domain: 2,
+      topic: "Redshift Maintenance",
+      difficulty: "medium"
+    },
+    {
+      id: 'd2_8',
+      question: "A company stores time-series data in DynamoDB for IoT sensor readings. Each sensor writes 1 KB records every second. After 30 days, data should be moved to cold storage. Which approach is MOST cost-effective?",
+      options: [
+        "Use DynamoDB TTL with S3 export",
+        "Use DynamoDB Streams with Lambda to archive to S3 Glacier",
+        "Enable DynamoDB Global Tables for replication",
+        "Use DynamoDB on-demand capacity mode"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "DynamoDB Streams with Lambda provides automatic archival workflow. When TTL deletes items, Streams captures the deletion, Lambda can write the data to S3 Glacier before it's removed.",
+      domain: 2,
+      topic: "Data Lifecycle",
+      difficulty: "hard"
+    },
+    {
+      id: 'd2_9',
+      question: "A data lake uses S3 with millions of small files (1-10 KB each). Athena queries are slow despite using Parquet format. What optimization should be implemented?",
+      options: [
+        "Enable S3 Transfer Acceleration",
+        "Compact small files into larger files (128MB-1GB)",
+        "Change to ORC format",
+        "Use S3 Intelligent-Tiering"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Small files create overhead as Athena must open each file separately. Compacting into larger files (128MB-1GB) reduces S3 API calls and improves query performance significantly.",
+      domain: 2,
+      topic: "File Optimization",
+      difficulty: "medium"
+    },
+    {
+      id: 'd2_10',
+      question: "A company runs complex analytical queries on Amazon Redshift. Some queries scan fact tables with billions of rows. The data engineer notices queries don't use zone maps effectively. What is the MOST likely cause?",
+      options: [
+        "Sort keys are not defined on frequently filtered columns",
+        "Distribution style is set to EVEN",
+        "The cluster has too few nodes",
+        "Workload Management (WLM) queues are misconfigured"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "Zone maps work with sort keys to skip blocks of data. Without proper sort keys on filtered columns, Redshift cannot use zone maps effectively for query optimization.",
+      domain: 2,
+      topic: "Redshift Performance",
+      difficulty: "hard"
+    },
+    {
+      id: 'd2_11',
+      question: "A data lake stores customer data that must comply with GDPR right-to-erasure requirements. Data is stored in Parquet format on S3 and cataloged in Glue. How should deletion requests be handled efficiently?",
+      options: [
+        "Rewrite entire Parquet files without deleted records",
+        "Use S3 Object Lock to prevent deletion",
+        "Implement Delta Lake or Apache Iceberg for record-level operations",
+        "Delete entire partitions containing the customer"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "Delta Lake or Apache Iceberg support ACID transactions and efficient record-level deletes. They track deleted records in metadata without rewriting entire files.",
+      domain: 2,
+      topic: "Data Lake ACID",
+      difficulty: "hard"
+    },
+    {
+      id: 'd2_12',
+      question: "An analytics workload on Redshift has unpredictable query patterns. Sometimes there are no queries for hours, then sudden bursts of complex queries. Which pricing model is MOST cost-effective?",
+      options: [
+        "Provisioned Redshift cluster with reserved instances",
+        "Redshift Serverless",
+        "Provisioned cluster with Concurrency Scaling",
+        "Multiple provisioned clusters in different regions"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Redshift Serverless automatically scales up during query bursts and scales to zero during idle periods. This is ideal for unpredictable workloads, charging only for actual usage.",
+      domain: 2,
+      topic: "Cost Optimization",
+      difficulty: "medium"
+    },
+    {
+      id: 'd2_13',
+      question: "A data engineer needs to query data across S3 data lake and Redshift tables in a single query. Which feature enables this?",
+      options: [
+        "Redshift Federated Query",
+        "Redshift Spectrum",
+        "AWS Glue ETL",
+        "Amazon Athena Federated Query"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Redshift Spectrum allows querying S3 data directly from Redshift using external tables. You can join Spectrum external tables with native Redshift tables in a single query.",
+      domain: 2,
+      topic: "Data Federation",
+      difficulty: "medium"
+    },
+    {
+      id: 'd2_14',
+      question: "A company migrates from on-premises Hadoop to AWS. The existing data lake uses Hive with ORC files. They want to minimize changes to existing ETL jobs. Which AWS service should host the metastore?",
+      options: [
+        "AWS Glue Data Catalog with Hive-compatible interface",
+        "Amazon RDS MySQL as external Hive metastore",
+        "Amazon DynamoDB for metadata storage",
+        "AWS Lake Formation with new metadata format"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "AWS Glue Data Catalog is Hive metastore compatible. It can serve as a drop-in replacement for Hive metastore, minimizing changes to existing ETL jobs that use HiveContext or SparkSQL.",
+      domain: 2,
+      topic: "Metadata Management",
+      difficulty: "medium"
+    },
+    {
+      id: 'd2_15',
+      question: "A data lake has grown to 500 TB across 10,000 tables. Different teams need access to different subsets of data. Managing individual IAM policies has become complex. Which solution simplifies access control?",
+      options: [
+        "Create IAM groups for each team",
+        "Use S3 bucket policies with prefixes",
+        "Implement Lake Formation with tag-based access control",
+        "Set up VPC endpoints for each team"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "Lake Formation tag-based access control (LF-TBAC) allows tagging resources and defining access based on tags. This scales much better than managing individual resource policies.",
+      domain: 2,
+      topic: "Access Control",
+      difficulty: "medium"
+    },
+    {
+      id: 'd2_16',
+      question: "A Redshift cluster stores 10 TB of data with 5 years of history. 90% of queries access only the last 3 months of data. How should data be organized for optimal cost and performance?",
+      options: [
+        "Archive old data to S3, keep recent data in Redshift, use Spectrum for historical queries",
+        "Keep all data in Redshift with interleaved sort keys",
+        "Move all data to S3 and use Athena exclusively",
+        "Create separate Redshift clusters for historical and recent data"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "Archiving older data to S3 and querying via Spectrum reduces Redshift storage costs while keeping recent hot data in Redshift for performance.",
+      domain: 2,
+      topic: "Hot/Cold Data",
+      difficulty: "hard"
+    },
+    {
+      id: 'd2_17',
+      question: "A DynamoDB table serves both transactional and analytical workloads. Analytical queries cause throttling on the main table. Which solution addresses this without affecting transactions?",
+      options: [
+        "Increase provisioned capacity",
+        "Enable DynamoDB Global Tables",
+        "Export data to S3 and use Athena for analytics",
+        "Create a Global Secondary Index for analytical queries"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "Exporting DynamoDB data to S3 and using Athena separates analytical workloads from transactional. This prevents analytics from consuming capacity that impacts transactional queries.",
+      domain: 2,
+      topic: "Workload Separation",
+      difficulty: "medium"
+    },
+    {
+      id: 'd2_18',
+      question: "A data lake team needs to maintain multiple versions of datasets for reproducibility. Users should be able to query historical states of data. Which approach provides this capability?",
+      options: [
+        "S3 versioning with Athena",
+        "Apache Iceberg tables with time travel",
+        "Glue job bookmarks",
+        "S3 replication to backup bucket"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Apache Iceberg supports time travel queries allowing users to query data as of a specific timestamp or snapshot. This provides data versioning with efficient storage and query capabilities.",
+      domain: 2,
+      topic: "Data Versioning",
+      difficulty: "hard"
+    }
+  ],
+
+  // Domain 3: Data Operations and Support (22% - 15 questions)
+  3: [
+    {
+      id: 'd3_1',
+      question: "A data pipeline runs daily at 2 AM using Amazon MWAA (Managed Airflow). The pipeline has started failing intermittently. What should the data engineer use to identify the root cause?",
+      options: [
+        "Check AWS CloudTrail logs only",
+        "Review Airflow task logs in CloudWatch Logs and MWAA metrics",
+        "Enable VPC Flow Logs",
+        "Check S3 access logs"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Amazon MWAA integrates with CloudWatch Logs for Airflow task logs and provides MWAA-specific metrics in CloudWatch. This combination provides visibility into task execution for troubleshooting.",
+      domain: 3,
+      topic: "Monitoring and Logging",
+      difficulty: "medium"
+    },
+    {
+      id: 'd3_2',
+      question: "A company needs to implement data quality checks in their AWS Glue ETL pipeline. They want to validate that email addresses match a valid format and customer_id has no null values. What should they use?",
+      options: [
+        "AWS Glue DataBrew data profiling",
+        "AWS Glue Data Quality with DQDL rules",
+        "Custom PySpark validation code in Glue",
+        "Amazon Athena queries after loading"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "AWS Glue Data Quality with Data Quality Definition Language (DQDL) allows defining validation rules like CustomSql, ColumnValues, and Completeness checks natively in Glue ETL.",
+      domain: 3,
+      topic: "Data Quality",
+      difficulty: "medium"
+    },
+    {
+      id: 'd3_3',
+      question: "An ETL pipeline uses AWS Step Functions to orchestrate AWS Glue jobs. The team needs to receive alerts when any job fails. What is the MOST efficient way to implement this?",
+      options: [
+        "Add a Catch state that invokes Lambda to send SNS notifications",
+        "Create CloudWatch Alarms for each Glue job",
+        "Poll Step Functions execution status using Lambda",
+        "Enable AWS Config rules for Step Functions"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "Using a Catch state in Step Functions that invokes Lambda to send SNS notifications provides centralized error handling at the workflow level and immediate notifications.",
+      domain: 3,
+      topic: "Alerting",
+      difficulty: "medium"
+    },
+    {
+      id: 'd3_4',
+      question: "A data engineer needs to optimize costs for an AWS Glue ETL workload that runs 4 hours daily. The job uses 20 DPUs. What cost optimization strategy should be considered?",
+      options: [
+        "Use Glue Auto Scaling to optimize DPU usage",
+        "Run the job on Amazon EMR instead",
+        "Increase DPUs to complete faster",
+        "Use Glue version 0.9 for lower costs"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "AWS Glue Auto Scaling automatically adjusts workers based on actual resource needs. This can significantly reduce costs by using fewer DPUs when full capacity isn't needed.",
+      domain: 3,
+      topic: "Cost Optimization",
+      difficulty: "medium"
+    },
+    {
+      id: 'd3_5',
+      question: "A company needs to implement a data pipeline that triggers when new files arrive in S3. The pipeline should process files in order and handle retries automatically. Which orchestration approach is recommended?",
+      options: [
+        "S3 Event  SNS  Lambda",
+        "S3 Event  EventBridge  Step Functions",
+        "S3 Event  SQS  Lambda (polling)",
+        "CloudWatch Events  Lambda  Glue"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "S3 Event to EventBridge to Step Functions provides reliable event capture with built-in retry logic, error handling, and execution state management.",
+      domain: 3,
+      topic: "Event-Driven Architecture",
+      difficulty: "hard"
+    },
+    {
+      id: 'd3_6',
+      question: "A data team runs 50+ Glue jobs with complex dependencies. Managing job scheduling and dependencies has become difficult. Which solution provides better orchestration?",
+      options: [
+        "AWS Glue Workflows",
+        "EventBridge Scheduler with Lambda",
+        "Amazon MWAA (Managed Apache Airflow)",
+        "Step Functions Standard Workflows"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "Amazon MWAA provides a full-featured workflow orchestration with rich DAG visualization, dependency management, and extensive operator ecosystem for complex job dependencies.",
+      domain: 3,
+      topic: "Workflow Orchestration",
+      difficulty: "medium"
+    },
+    {
+      id: 'd3_7',
+      question: "A streaming pipeline occasionally drops records during high-volume periods. The data engineer needs to identify which records were lost and from which source. Which approach enables this investigation?",
+      options: [
+        "Enable CloudWatch detailed monitoring",
+        "Implement record counting at each pipeline stage with reconciliation",
+        "Increase Kinesis shard count",
+        "Enable S3 server access logging"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Implementing record counting at each stage allows reconciliation between source and destination. This identifies exactly where and how many records are lost in the pipeline.",
+      domain: 3,
+      topic: "Data Reconciliation",
+      difficulty: "hard"
+    },
+    {
+      id: 'd3_8',
+      question: "An AWS Glue job writes data to S3, but downstream consumers occasionally see incomplete data. The job logs show successful completion. What is the MOST likely cause?",
+      options: [
+        "Eventual consistency of S3",
+        "Glue job is not committing the transaction",
+        "Files are being written without _SUCCESS marker or manifest",
+        "CloudWatch logs are delayed"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "Without a _SUCCESS marker or manifest file, downstream consumers may read incomplete data as Glue writes multiple files. The marker signals job completion for safe consumption.",
+      domain: 3,
+      topic: "Job Completion Signaling",
+      difficulty: "hard"
+    },
+    {
+      id: 'd3_9',
+      question: "A company needs to run Spark jobs on EMR but wants to minimize cluster management overhead. Jobs run for 2-4 hours daily. Which EMR deployment option is MOST suitable?",
+      options: [
+        "EMR on EC2 with long-running cluster",
+        "EMR on EKS",
+        "EMR Serverless",
+        "EMR on EC2 with transient clusters"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "EMR Serverless eliminates cluster management entirely. Jobs run without provisioning or managing clusters. For 2-4 hour daily jobs, this provides minimal overhead and pay-per-use billing.",
+      domain: 3,
+      topic: "Managed Services",
+      difficulty: "medium"
+    },
+    {
+      id: 'd3_10',
+      question: "A data pipeline must meet an SLA of 99.9% availability. The pipeline uses Lambda, Glue, and S3. Which monitoring strategy ensures SLA compliance?",
+      options: [
+        "CloudWatch Logs only",
+        "Custom dashboard with CloudWatch Metrics, Alarms, and automated remediation",
+        "AWS X-Ray tracing only",
+        "Manual log review daily"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "A comprehensive monitoring strategy with CloudWatch Metrics for uptime tracking, Alarms for immediate detection, and automated remediation ensures 99.9% SLA compliance.",
+      domain: 3,
+      topic: "SLA Monitoring",
+      difficulty: "medium"
+    },
+    {
+      id: 'd3_11',
+      question: "A Glue job processes data from multiple S3 prefixes. The job should only process new files since the last successful run. Which feature enables this?",
+      options: [
+        "S3 Inventory",
+        "AWS Glue job bookmarks",
+        "S3 event notifications",
+        "AWS Glue triggers"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Glue job bookmarks track which files have been processed, allowing the job to automatically process only new or unprocessed files in subsequent runs.",
+      domain: 3,
+      topic: "Incremental Processing",
+      difficulty: "easy"
+    },
+    {
+      id: 'd3_12',
+      question: "A data pipeline team needs to implement blue-green deployment for their ETL jobs. How should they approach this for AWS Glue jobs?",
+      options: [
+        "Use Glue versions feature",
+        "Maintain separate job definitions with version suffixes and swap aliases",
+        "Use AWS CodePipeline with Glue deployment actions",
+        "Clone jobs manually before updates"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Maintaining separate job definitions (blue/green versions) with workflow aliases allows safe deployment. Test the new version, then swap the alias to point to green, enabling instant rollback.",
+      domain: 3,
+      topic: "Deployment Strategy",
+      difficulty: "hard"
+    },
+    {
+      id: 'd3_13',
+      question: "An MWAA environment runs out of memory when running many parallel tasks. Task logs show OOM errors. What should be modified? (Select TWO)",
+      options: [
+        "Increase MWAA environment size",
+        "Reduce parallelism configuration in Airflow",
+        "Use larger S3 bucket",
+        "Enable MWAA auto-scaling",
+        "Reduce DAG complexity"
+      ],
+      correctAnswer: null,
+      correctAnswers: [0, 1],
+      type: "multiple",
+      selectCount: 2,
+      explanation: "Increasing MWAA environment size provides more memory. Reducing parallelism limits concurrent tasks, preventing memory exhaustion. Both directly address OOM issues.",
+      domain: 3,
+      topic: "MWAA Tuning",
+      difficulty: "hard"
+    },
+    {
+      id: 'd3_14',
+      question: "A data team wants to implement CI/CD for their Glue ETL scripts stored in Git. Which AWS service best integrates with Git for automated Glue deployments?",
+      options: [
+        "AWS CodePipeline with CodeBuild",
+        "AWS CloudFormation StackSets",
+        "AWS Systems Manager Automation",
+        "AWS Glue DevEndpoints"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "AWS CodePipeline integrates with Git repositories (CodeCommit, GitHub) and can use CodeBuild to test and deploy Glue ETL scripts automatically when changes are pushed.",
+      domain: 3,
+      topic: "CI/CD",
+      difficulty: "medium"
+    },
+    {
+      id: 'd3_15',
+      question: "A company needs to replay failed Kinesis stream records from 6 hours ago. The stream retention is set to 24 hours. How should the data engineer accomplish this?",
+      options: [
+        "Use GetShardIterator with AT_TIMESTAMP",
+        "Restore from Kinesis backup",
+        "Use Kinesis Data Firehose error logging",
+        "Increase stream retention to 7 days"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "GetShardIterator with AT_TIMESTAMP allows reading from a specific point in time within the retention period. This enables replaying records from exactly when failures occurred.",
+      domain: 3,
+      topic: "Stream Replay",
+      difficulty: "hard"
+    }
+  ],
+
+  // Domain 4: Data Security and Governance (18% - 12 questions)
+  4: [
+    {
+      id: 'd4_1',
+      question: "A company needs to ensure that sensitive customer data in Amazon S3 is encrypted with keys that the company manages and can rotate annually. What should be implemented?",
+      options: [
+        "S3 Server-Side Encryption with S3-Managed Keys (SSE-S3)",
+        "S3 Server-Side Encryption with KMS Customer Managed Keys (SSE-KMS)",
+        "Client-side encryption before upload",
+        "S3 Server-Side Encryption with Customer-Provided Keys (SSE-C)"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "SSE-KMS with Customer Managed Keys (CMK) allows the company to manage keys in AWS KMS, including automatic annual rotation. KMS provides audit trails through CloudTrail.",
+      domain: 4,
+      topic: "Encryption",
+      difficulty: "medium"
+    },
+    {
+      id: 'd4_2',
+      question: "A data lake uses AWS Lake Formation for access control. A new analyst needs read access to only the 'name' and 'email' columns in 'customers' table, but not 'ssn' or 'credit_card' columns. How should this be implemented?",
+      options: [
+        "Create an IAM policy with column-level S3 object permissions",
+        "Use Lake Formation column-level security grants",
+        "Create a view in Athena that excludes sensitive columns",
+        "Use S3 Access Points with column filtering"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "AWS Lake Formation supports column-level security grants, allowing you to grant SELECT permission on specific columns to users or groups.",
+      domain: 4,
+      topic: "Access Control",
+      difficulty: "medium"
+    },
+    {
+      id: 'd4_3',
+      question: "A company stores data in Amazon Redshift that contains PII. Regulatory requirements mandate that all queries accessing PII columns must be logged. Which feature should be enabled?",
+      options: [
+        "Redshift Audit Logging to S3",
+        "VPC Flow Logs",
+        "AWS CloudTrail data events",
+        "Amazon CloudWatch Logs Insights"
+      ],
+      correctAnswer: 0,
+      correctAnswers: [0],
+      type: "single",
+      explanation: "Redshift Audit Logging captures user activity including SQL statements. Logs can be stored in S3 for analysis and compliance.",
+      domain: 4,
+      topic: "Audit Logging",
+      difficulty: "medium"
+    },
+    {
+      id: 'd4_4',
+      question: "An AWS Glue ETL job needs to access credentials for a third-party database. The credentials must be encrypted and automatically rotated. Which service should store these credentials?",
+      options: [
+        "AWS Systems Manager Parameter Store (SecureString)",
+        "AWS Secrets Manager with rotation enabled",
+        "Hardcode in AWS Glue job parameters (encrypted)",
+        "Store in a private S3 bucket with SSE-S3"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "AWS Secrets Manager supports automatic credential rotation with built-in Lambda functions. Glue can retrieve secrets at runtime using the Secrets Manager API.",
+      domain: 4,
+      topic: "Secrets Management",
+      difficulty: "medium"
+    },
+    {
+      id: 'd4_5',
+      question: "A data lake needs to track data lineage to understand how data flows from source to final reports. Which AWS service provides this capability?",
+      options: [
+        "AWS X-Ray",
+        "AWS CloudTrail",
+        "AWS Glue Data Catalog with lineage tracking",
+        "Amazon Detective"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "AWS Glue Data Catalog can track data lineage through Glue jobs, showing how tables are created and transformed. Lake Formation also provides lineage views.",
+      domain: 4,
+      topic: "Data Lineage",
+      difficulty: "medium"
+    },
+    {
+      id: 'd4_6',
+      question: "A company needs to automatically discover and classify sensitive data (PII, financial data) stored across S3 buckets in their data lake. Which service should be used?",
+      options: [
+        "AWS Config",
+        "Amazon Macie",
+        "Amazon Inspector",
+        "AWS Trusted Advisor"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Amazon Macie uses machine learning to automatically discover, classify, and protect sensitive data in S3. It can identify PII, financial data, and other sensitive information types.",
+      domain: 4,
+      topic: "Data Discovery",
+      difficulty: "easy"
+    },
+    {
+      id: 'd4_7',
+      question: "A company must comply with data residency requirements ensuring certain data never leaves a specific AWS region. How should this be enforced for S3?",
+      options: [
+        "Use S3 Object Lock",
+        "Configure S3 bucket policies with aws:RequestedRegion condition",
+        "Enable S3 Cross-Region Replication blocking",
+        "Use AWS Organizations SCP to deny cross-region operations"
+      ],
+      correctAnswer: 3,
+      correctAnswers: [3],
+      type: "single",
+      explanation: "AWS Organizations Service Control Policies (SCPs) can enforce region restrictions at the organization level, preventing any cross-region operations.",
+      domain: 4,
+      topic: "Data Residency",
+      difficulty: "hard"
+    },
+    {
+      id: 'd4_8',
+      question: "A data pipeline processes data from external partners. The data should be scanned for malware before processing. Which approach is MOST appropriate?",
+      options: [
+        "Use AWS WAF on the ingestion endpoint",
+        "Implement Lambda-based scanning using ClamAV or similar",
+        "Enable S3 Object Lambda for scanning on access",
+        "Use Amazon GuardDuty for S3"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "Lambda-based malware scanning (using ClamAV or commercial tools) triggered by S3 upload events provides file-level malware detection before processing.",
+      domain: 4,
+      topic: "Security Scanning",
+      difficulty: "medium"
+    },
+    {
+      id: 'd4_9',
+      question: "A data warehouse team needs to implement dynamic data masking in Redshift. Certain users should see actual SSN values while others see masked versions. Which approach works?",
+      options: [
+        "Create separate tables for different user groups",
+        "Use Redshift row-level security (RLS)",
+        "Create views with CASE statements based on current_user and grant access to views",
+        "Use Redshift column-level encryption"
+      ],
+      correctAnswer: 2,
+      correctAnswers: [2],
+      type: "single",
+      explanation: "Creating views with conditional logic based on current_user allows showing real or masked data based on who is querying. This provides dynamic masking without data duplication.",
+      domain: 4,
+      topic: "Data Masking",
+      difficulty: "hard"
+    },
+    {
+      id: 'd4_10',
+      question: "A company uses Kinesis Data Streams for sensitive financial data. They require encryption in transit and at rest. Which configuration ensures this? (Select TWO)",
+      options: [
+        "Enable server-side encryption on the Kinesis stream",
+        "Use HTTPS endpoints for producers and consumers",
+        "Enable VPC flow logs",
+        "Use IAM roles instead of access keys",
+        "Enable CloudTrail logging"
+      ],
+      correctAnswer: null,
+      correctAnswers: [0, 1],
+      type: "multiple",
+      selectCount: 2,
+      explanation: "Server-side encryption (SSE) protects data at rest in Kinesis. HTTPS endpoints ensure encryption in transit. Together they provide complete encryption coverage.",
+      domain: 4,
+      topic: "Stream Security",
+      difficulty: "medium"
+    },
+    {
+      id: 'd4_11',
+      question: "A data lake processes healthcare data subject to HIPAA. Data in S3 must be encrypted, and access must be logged for audit. Which combination of services ensures compliance? (Select TWO)",
+      options: [
+        "S3 SSE-KMS encryption",
+        "AWS CloudTrail with S3 data events",
+        "Amazon Macie",
+        "AWS Config",
+        "S3 Transfer Acceleration"
+      ],
+      correctAnswer: null,
+      correctAnswers: [0, 1],
+      type: "multiple",
+      selectCount: 2,
+      explanation: "SSE-KMS provides HIPAA-compliant encryption with key management. CloudTrail with S3 data events logs all access for audit requirements.",
+      domain: 4,
+      topic: "HIPAA Compliance",
+      difficulty: "medium"
+    },
+    {
+      id: 'd4_12',
+      question: "A Glue job needs to access resources in a private subnet with no internet access. The job must read from S3 and write to Redshift. What network configuration is required?",
+      options: [
+        "NAT Gateway for S3 and Redshift access",
+        "VPC endpoints for S3 and Redshift",
+        "Internet Gateway with security groups",
+        "AWS PrivateLink for S3 only"
+      ],
+      correctAnswer: 1,
+      correctAnswers: [1],
+      type: "single",
+      explanation: "VPC endpoints (Gateway endpoint for S3, Interface endpoint for Redshift) allow private subnet access without internet. This maintains security while enabling necessary connectivity.",
+      domain: 4,
+      topic: "Network Security",
+      difficulty: "medium"
+    }
+  ]
+}
+
+export default function AWSExam() {
+  const { sessionId } = useParams()
+  const location = useLocation()
+  const navigate = useNavigate()
+  const { user } = useAuth()
+
+  const [questions, setQuestions] = useState([])
+  const [currentIndex, setCurrentIndex] = useState(0)
+  const [answers, setAnswers] = useState({})
+  const [flagged, setFlagged] = useState([])
+  const [timeLeft, setTimeLeft] = useState(0)
+  const [phase, setPhase] = useState('loading')
+  const [showExplanation, setShowExplanation] = useState(false)
+  const [results, setResults] = useState(null)
+  const [examConfig, setExamConfig] = useState(null)
+
+  // --- MALPRACTICE DETECTION SYSTEM ---
+  // 1. Track Tab Switches (User leaves the quiz tab)
+  useEffect(() => {
+    const handleVisibilityChange = () => {
+      // Only track if the exam is actively running
+      if (document.hidden && user && sessionId && phase === 'running') {
+        fetch(${import.meta.env.VITE_API_URL || 'https://mcq-practice-api.onrender.com'} + '/api/malpractice/log-violation', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            sessionId: sessionId || 'aws-exam-session',
+            userId: user.uid,
+            userName: user.displayName || 'Student',
+            category: 'AWS DEA-C01',
+            violationType: 'tab_switch',
+            severity: 'medium',
+            metadata: { questionIndex: currentIndex }
+          })
+        }).catch(err => console.warn('Malpractice log failed:', err));
+      }
+    };
+
+    document.addEventListener('visibilitychange', handleVisibilityChange);
+    return () => document.removeEventListener('visibilitychange', handleVisibilityChange);
+  }, [sessionId, user, currentIndex, phase]);
+
+  // 2. Track Copy/Paste disabled & attempts
+  useEffect(() => {
+    const handleCopy = (e) => {
+      if (user && sessionId && phase === 'running') {
+        fetch(${import.meta.env.VITE_API_URL || 'https://mcq-practice-api.onrender.com'} + '/api/malpractice/log-violation', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            sessionId: sessionId || 'aws-exam-session',
+            userId: user.uid,
+            userName: user.displayName || 'Student',
+            violationType: 'copy_attempt',
+            severity: 'high',
+            metadata: { questionIndex: currentIndex }
+          })
+        }).catch(err => console.warn('Malpractice log failed:', err));
+        
+        // Prevent copying in AWS Exam
+        e.preventDefault();
+      }
+    };
+
+    document.addEventListener('copy', handleCopy);
+    return () => document.removeEventListener('copy', handleCopy);
+  }, [sessionId, user, currentIndex, phase]);
+
+  // 3. Full Screen Enforcement & Tracking
+  useEffect(() => {
+    if (phase !== 'running') return; // Only enforce during running phase
+    
+    // Attempt to enter full screen
+    const enterFullScreen = async () => {
+      try {
+        const elem = document.documentElement;
+        if (elem.requestFullscreen) {
+          await elem.requestFullscreen();
+        } else if (elem.webkitRequestFullscreen) { /* Safari */
+          await elem.webkitRequestFullscreen();
+        } else if (elem.msRequestFullscreen) { /* IE11 */
+          await elem.msRequestFullscreen();
+        }
+      } catch (err) {
+        console.warn('Browser blocked auto-fullscreen (requires user click):', err);
+      }
+    };
+
+    // Browsers require a user gesture
+    const handleFirstClick = () => {
+      if (!document.fullscreenElement) enterFullScreen();
+      document.removeEventListener('click', handleFirstClick);
+    };
+
+    enterFullScreen();
+    document.addEventListener('click', handleFirstClick);
+
+    // Track if they exit full screen
+    const handleFullScreenChange = () => {
+      if (!document.fullscreenElement && user && sessionId && phase === 'running') {
+        fetch(${import.meta.env.VITE_API_URL || 'https://mcq-practice-api.onrender.com'} + '/api/malpractice/log-violation', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            sessionId: sessionId || 'aws-exam-session',
+            userId: user.uid,
+            userName: user.displayName || 'Student',
+            violationType: 'fullscreen_exit', // Send as violation
+            severity: 'high',
+            metadata: { questionIndex: currentIndex }
+          })
+        }).catch(err => console.warn('Malpractice log failed:', err));
+      }
+    };
+
+    document.addEventListener('fullscreenchange', handleFullScreenChange);
+    return () => {
+      document.removeEventListener('click', handleFirstClick);
+      document.removeEventListener('fullscreenchange', handleFullScreenChange);
+      // Exit full screen when navigating away or finishing
+      if (document.fullscreenElement) {
+        document.exitFullscreen().catch(e => console.log(e));
+      }
+    };
+  }, [sessionId, user, currentIndex, phase]);
+  // ------------------------------------
+
+  useEffect(() => {
+    loadExam()
+  }, [])
+
+  useEffect(() => {
+    if (phase !== 'running' || timeLeft <= 0 || examConfig?.mode === 'review') return
+
+    const timer = setInterval(() => {
+      setTimeLeft(prev => {
+        if (prev <= 1) {
+          clearInterval(timer)
+          submitExam()
+          return 0
+        }
+        return prev - 1
+      })
+    }, 1000)
+
+    return () => clearInterval(timer)
+  }, [phase, timeLeft])
+
+  const loadExam = async () => {
+    try {
+      const config = location.state
+      if (!config) {
+        navigate('/aws-certification')
+        return
+      }
+
+      // Force config for Random Mix
+      if (config.paper === 'random-mix') {
+        config.questionCount = 65
+        config.duration = 130
+      }
+
+      setExamConfig(config)
+
+      let selectedQuestions = []
+
+      // Handling Random Mix with Domain Weightage
+      if (config.paper === 'random-mix') {
+        const allQuestions = [
+          ...DEA_C01_PRACTICE_QUESTIONS,
+          ...DEA_C01_PAPER_2_QUESTIONS,
+          ...DEA_C01_PAPER_3_QUESTIONS,
+          ...DEA_C01_PAPER_4_QUESTIONS,
+          ...DEA_C01_PAPER_5_QUESTIONS,
+          ...DEA_C01_PAPER_6_QUESTIONS,
+          ...DEA_C01_PAPER_8_QUESTIONS
+        ]
+
+        // 1. Map domains with refined logic
+        const mappedQuestions = allQuestions.map(q => {
+          const t = (q.topic || '').toLowerCase()
+          let domain = 4 // Default to Security & Governance if unclassified
+
+          // Domain 4: Security & Governance (Priority Check)
+          if (t.includes('iam') || t.includes('kms') || t.includes('lake formation') || t.includes('secrets manager') || t.includes('cloudtrail') || t.includes('macie') || t.includes('encryption') || t.includes('security') || t.includes('permission') || t.includes('governance') || t.includes('vpc') || t.includes('pii') || t.includes('compliance')) {
+            domain = 4
+          }
+          // Domain 3: Data Operations and Support
+          else if (t.includes('step functions') || t.includes('emr') || t.includes('mwaa') || t.includes('airflow') || t.includes('cloudwatch') || t.includes('x-ray') || t.includes('eventbridge') || t.includes('sns') || t.includes('sqs') || t.includes('orchestration') || t.includes('monitoring') || t.includes('logging') || t.includes('debugging') || t.includes('troubleshooting')) {
+            domain = 3
+          }
+          // Domain 2: Data Store Management
+          else if (t.includes('redshift') || t.includes('s3') || t.includes('athena') || t.includes('dynamodb') || t.includes('opensearch') || t.includes('rds') || t.includes('aurora') || t.includes('storage') || t.includes('partition') || t.includes('nosql') || t.includes('deduplication')) {
+            domain = 2
+          }
+          // Domain 1: Data Ingestion and Transformation
+          else if (t.includes('glue') || t.includes('kinesis') || t.includes('lambda') || t.includes('dms') || t.includes('appflow') || t.includes('kafka') || t.includes('msk') || t.includes('flink') || t.includes('ingestion') || t.includes('etl') || t.includes('datasync') || t.includes('transfer')) {
+            domain = 1
+          }
+
+          return {
+            ...q,
+            domain,
+            explanation: q.explanation || `Correct answer for this ${q.topic} question.`
+          }
+        })
+
+        // 2. Group by domain
+        const byDomain = { 1: [], 2: [], 3: [], 4: [] }
+        mappedQuestions.forEach(q => {
+          if (byDomain[q.domain]) byDomain[q.domain].push(q)
+        })
+
+        // 3. Select based on weightage
+        // Domain 1: 34% (~22 q)
+        // Domain 2: 26% (~17 q)
+        // Domain 3: 22% (~14 q)
+        // Domain 4: 18% (~12 q)
+        const d1 = byDomain[1].sort(() => Math.random() - 0.5).slice(0, 22)
+        const d2 = byDomain[2].sort(() => Math.random() - 0.5).slice(0, 17)
+        const d3 = byDomain[3].sort(() => Math.random() - 0.5).slice(0, 14)
+        const d4 = byDomain[4].sort(() => Math.random() - 0.5).slice(0, 12)
+
+        selectedQuestions = [...d1, ...d2, ...d3, ...d4]
+          .sort(() => Math.random() - 0.5) // Final shuffle
+
+        setQuestions(selectedQuestions)
+        setTimeLeft(config.duration * 60)
+        setPhase('running')
+        return // Exit early
+      }
+
+      // Standard logic for other papers
+      let paperQuestions = []
+      switch (config.paper) {
+        case 'paper2':
+          paperQuestions = DEA_C01_PAPER_2_QUESTIONS
+          break
+        case 'paper3':
+          paperQuestions = DEA_C01_PAPER_3_QUESTIONS
+          break
+        case 'paper6':
+          paperQuestions = DEA_C01_PAPER_6_QUESTIONS
+          break
+        case 'paper4':
+          paperQuestions = DEA_C01_PAPER_4_QUESTIONS
+          break
+        case 'paper5':
+          paperQuestions = DEA_C01_PAPER_5_QUESTIONS
+          break
+        case 'paper8':
+          paperQuestions = DEA_C01_PAPER_8_QUESTIONS
+          break
+        case 'paper1':
+        default:
+          paperQuestions = DEA_C01_PRACTICE_QUESTIONS
+      }
+
+      // Map questions with domain information
+      selectedQuestions = paperQuestions.map(q => ({
+        ...q,
+        domain: q.topic?.includes('Glue') || q.topic?.includes('Kinesis') || q.topic?.includes('Lambda') ? 1 :
+          q.topic?.includes('Redshift') || q.topic?.includes('S3') || q.topic?.includes('Athena') ? 2 :
+            q.topic?.includes('Step Functions') || q.topic?.includes('EMR') ? 3 : 4,
+        explanation: q.explanation || `Correct answer for this ${q.topic} question.`
+      }))
+
+      selectedQuestions = selectedQuestions
+        .sort(() => Math.random() - 0.5)
+        .slice(0, config.questionCount)
+
+      setQuestions(selectedQuestions)
+      setTimeLeft(config.duration * 60)
+      setPhase('running')
+    } catch (error) {
+      console.error('Error loading exam:', error)
+    }
+  }
+
+  const selectAnswer = (questionIndex, optionIndex) => {
+    const question = questions[questionIndex]
+
+    if (question.type === 'multiple') {
+      const currentAnswers = answers[questionIndex] || []
+      if (currentAnswers.includes(optionIndex)) {
+        setAnswers({
+          ...answers,
+          [questionIndex]: currentAnswers.filter(a => a !== optionIndex)
+        })
+      } else if (currentAnswers.length < (question.selectCount || 2)) {
+        setAnswers({
+          ...answers,
+          [questionIndex]: [...currentAnswers, optionIndex]
+        })
+      }
+    } else {
+      setAnswers({
+        ...answers,
+        [questionIndex]: optionIndex
+      })
+    }
+  }
+
+  const toggleFlag = (index) => {
+    if (flagged.includes(index)) {
+      setFlagged(flagged.filter(i => i !== index))
+    } else {
+      setFlagged([...flagged, index])
+    }
+  }
+
+  const isCorrect = (questionIndex) => {
+    const question = questions[questionIndex]
+    const answer = answers[questionIndex]
+
+    if (question.type === 'multiple') {
+      if (!Array.isArray(answer)) return false
+      return question.correctAnswers.every(c => answer.includes(c)) &&
+        answer.every(a => question.correctAnswers.includes(a))
+    } else {
+      return answer === question.correctAnswer
+    }
+  }
+
+  const submitExam = async () => {
+    let correct = 0
+    let attempted = 0
+    const domainScores = { 1: { correct: 0, total: 0 }, 2: { correct: 0, total: 0 }, 3: { correct: 0, total: 0 }, 4: { correct: 0, total: 0 } }
+
+    questions.forEach((q, index) => {
+      domainScores[q.domain].total++
+
+      if (answers[index] !== undefined) {
+        attempted++
+        if (isCorrect(index)) {
+          correct++
+          domainScores[q.domain].correct++
+        }
+      }
+    })
+
+    const rawScore = (correct / questions.length) * 100
+    const scaledScore = Math.round(100 + (rawScore * 9))
+
+    const examResults = {
+      totalQuestions: questions.length,
+      attempted,
+      correct,
+      wrong: attempted - correct,
+      unanswered: questions.length - attempted,
+      rawScore: Math.round(rawScore),
+      scaledScore,
+      passed: scaledScore >= 720,
+      domainScores,
+      timeSpent: examConfig.duration * 60 - timeLeft,
+      examType: 'aws-dea',
+      completedAt: new Date().toISOString()
+    }
+
+    setResults(examResults)
+    setPhase('completed')
+
+    if (user && sessionId) {
+      try {
+        await updateDoc(doc(db, 'sessions', sessionId), {
+          ...examResults,
+          status: 'completed'
+        })
+
+        // Update AWS Leaderboard
+        const awsLeaderboardRef = doc(db, 'aws-leaderboard', user.uid)
+        const existing = await getDoc(awsLeaderboardRef)
+
+        if (existing.exists()) {
+          const currentData = existing.data()
+          await updateDoc(awsLeaderboardRef, {
+            bestScore: Math.max(currentData.bestScore || 0, scaledScore),
+            totalExams: (currentData.totalExams || 0) + 1,
+            passed: currentData.passed || scaledScore >= 720,
+            lastActive: new Date(),
+            userName: user.displayName,
+            photoURL: user.photoURL
+          })
+        } else {
+          await setDoc(awsLeaderboardRef, {
+            userId: user.uid,
+            userName: user.displayName,
+            photoURL: user.photoURL,
+            bestScore: scaledScore,
+            totalExams: 1,
+            passed: scaledScore >= 720,
+            lastActive: new Date()
+          })
+        }
+
+        // Update User Statistics (Dashboard)
+        const userRef = doc(db, 'users', user.uid)
+        await updateDoc(userRef, {
+          totalTests: increment(1),
+          totalQuestions: increment(questions.length),
+          totalCorrect: increment(correct),
+          lastActivity: serverTimestamp()
+        })
+
+        // Update Streak
+        await updateStreak(user.uid)
+      } catch (error) {
+        console.error('Error saving results:', error)
+      }
+    }
+  }
+
+  const formatTime = (seconds) => {
+    const mins = Math.floor(seconds / 60)
+    const secs = seconds % 60
+    return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
+  }
+
+  if (phase === 'loading') {
+    return (
+      <div className="min-h-screen flex items-center justify-center">
+        <div className="text-center">
+          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-primary-600 mx-auto mb-4" />
+          <p className="text-gray-600 dark:text-gray-400">Loading AWS Exam...</p>
+        </div>
+      </div>
+    )
+  }
+
+  if (phase === 'completed' && results) {
+    return (
+      <div className="max-w-4xl mx-auto px-4 py-8">
+        <div className="card text-center mb-8">
+          <Cloud className="w-16 h-16 mx-auto mb-4 text-orange-500" />
+          <h1 className="text-2xl font-bold mb-2 text-gray-900 dark:text-white">
+            AWS Data Engineer Associate - Results
+          </h1>
+
+          <div className={`p-6 rounded-xl mb-6 ${results.passed
+            ? 'bg-green-50 dark:bg-green-900/30 border-2 border-green-500'
+            : 'bg-red-50 dark:bg-red-900/30 border-2 border-red-500'
+            }`}>
+            <div className="text-5xl font-bold mb-2" style={{
+              color: results.passed ? '#10b981' : '#ef4444'
+            }}>
+              {results.scaledScore}/1000
+            </div>
+            <p className={`text-lg font-semibold ${results.passed ? 'text-green-700 dark:text-green-300' : 'text-red-700 dark:text-red-300'
+              }`}>
+              {results.passed ? '­ƒÄë PASSED! Congratulations!' : 'ÔØî Not Passed - Keep Practicing!'}
+            </p>
+            <p className="text-sm text-gray-600 dark:text-gray-400 mt-1">
+              Passing Score: 720/1000 | Your Raw Score: {results.rawScore}%
+            </p>
+          </div>
+
+          <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mb-6">
+            <div className="p-4 bg-gray-50 dark:bg-gray-700 rounded-lg">
+              <p className="text-2xl font-bold text-gray-900 dark:text-white">{results.totalQuestions}</p>
+              <p className="text-sm text-gray-500 dark:text-gray-400">Total</p>
+            </div>
+            <div className="p-4 bg-green-50 dark:bg-green-900/30 rounded-lg">
+              <p className="text-2xl font-bold text-green-600 dark:text-green-400">{results.correct}</p>
+              <p className="text-sm text-gray-500 dark:text-gray-400">Correct</p>
+            </div>
+            <div className="p-4 bg-red-50 dark:bg-red-900/30 rounded-lg">
+              <p className="text-2xl font-bold text-red-600 dark:text-red-400">{results.wrong}</p>
+              <p className="text-sm text-gray-500 dark:text-gray-400">Wrong</p>
+            </div>
+            <div className="p-4 bg-gray-50 dark:bg-gray-700 rounded-lg">
+              <p className="text-2xl font-bold text-gray-600 dark:text-gray-300">{results.unanswered}</p>
+              <p className="text-sm text-gray-500 dark:text-gray-400">Unanswered</p>
+            </div>
+          </div>
+
+          <div className="mb-6">
+            <h3 className="font-semibold text-gray-900 dark:text-white mb-4">Domain Performance</h3>
+            <div className="space-y-3">
+              {[
+                { id: 1, name: 'Data Ingestion & Transformation', weight: '34%' },
+                { id: 2, name: 'Data Store Management', weight: '26%' },
+                { id: 3, name: 'Data Operations & Support', weight: '22%' },
+                { id: 4, name: 'Data Security & Governance', weight: '18%' }
+              ].map(domain => {
+                const score = results.domainScores[domain.id]
+                const percentage = score.total > 0 ? Math.round((score.correct / score.total) * 100) : 0
+                return (
+                  <div key={domain.id} className="text-left">
+                    <div className="flex justify-between text-sm mb-1">
+                      <span className="text-gray-700 dark:text-gray-300">
+                        Domain {domain.id}: {domain.name}
+                      </span>
+                      <span className="font-medium text-gray-900 dark:text-white">
+                        {score.correct}/{score.total} ({percentage}%)
+                      </span>
+                    </div>
+                    <div className="w-full bg-gray-200 dark:bg-gray-700 rounded-full h-2">
+                      <div
+                        className={`h-2 rounded-full ${percentage >= 70 ? 'bg-green-500' : percentage >= 50 ? 'bg-yellow-500' : 'bg-red-500'
+                          }`}
+                        style={{ width: `${percentage}%` }}
+                      />
+                    </div>
+                  </div>
+                )
+              })}
+            </div>
+          </div>
+
+          <div className="flex gap-4">
+            <button
+              onClick={() => setPhase('review')}
+              className="flex-1 btn-secondary"
+            >
+              Review Answers
+            </button>
+            <button
+              onClick={() => navigate('/aws-certification')}
+              className="flex-1 btn-primary"
+            >
+              Practice Again
+            </button>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  const currentQuestion = questions[currentIndex]
+  const isReviewMode = examConfig?.mode === 'review' || phase === 'review'
+
+  if (!currentQuestion) {
+    return (
+      <div className="min-h-screen flex items-center justify-center">
+        <div className="text-center">
+          <p className="text-gray-600 dark:text-gray-400">No questions available</p>
+          <button onClick={() => navigate('/aws-certification')} className="btn-primary mt-4">
+            Back to AWS Certification
+          </button>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className="max-w-5xl mx-auto px-4 py-4">
+      <div className="flex items-center justify-between mb-4">
+        <div className="flex items-center gap-2">
+          <Cloud className="w-6 h-6 text-orange-500" />
+          <span className="font-bold text-gray-900 dark:text-white">AWS DEA Practice</span>
+        </div>
+        {!isReviewMode && timeLeft > 0 && (
+          <div className={`flex items-center gap-2 px-4 py-2 rounded-lg font-mono text-lg font-bold ${timeLeft < 300 ? 'bg-red-100 dark:bg-red-900/50 text-red-600 dark:text-red-400 animate-pulse' : 'bg-gray-100 dark:bg-gray-700 text-gray-900 dark:text-white'
+            }`}>
+            <Clock className="w-5 h-5" />
+            {formatTime(timeLeft)}
+          </div>
+        )}
+        {isReviewMode && (
+          <span className="px-3 py-1 bg-blue-100 dark:bg-blue-900/30 text-blue-700 dark:text-blue-300 rounded-lg text-sm font-medium">
+            Review Mode
+          </span>
+        )}
+      </div>
+
+      <div className="flex gap-4">
+        <div className="flex-1">
+          <div className="card">
+            <div className="flex items-center justify-between mb-4">
+              <div className="flex items-center gap-2">
+                <span className="text-sm text-gray-500 dark:text-gray-400">
+                  Question {currentIndex + 1} of {questions.length}
+                </span>
+                <span className="text-xs px-2 py-1 bg-orange-100 dark:bg-orange-900/30 text-orange-700 dark:text-orange-300 rounded">
+                  Domain {currentQuestion?.domain}
+                </span>
+                {currentQuestion?.type === 'multiple' && (
+                  <span className="text-xs px-2 py-1 bg-purple-100 dark:bg-purple-900/30 text-purple-700 dark:text-purple-300 rounded">
+                    Select {currentQuestion.selectCount}
+                  </span>
+                )}
+              </div>
+              <button
+                onClick={() => toggleFlag(currentIndex)}
+                className={`p-2 rounded ${flagged.includes(currentIndex)
+                  ? 'bg-orange-100 dark:bg-orange-900/50 text-orange-600 dark:text-orange-400'
+                  : 'bg-gray-100 dark:bg-gray-700 text-gray-600 dark:text-gray-400'
+                  }`}
+              >
+                <Flag className="w-4 h-4" />
+              </button>
+            </div>
+
+            <h3 className="text-lg font-medium mb-6 text-gray-900 dark:text-white">
+              {currentQuestion?.question}
+            </h3>
+
+
+            <div className="space-y-3">
+              {currentQuestion?.options?.map((option, index) => {
+                const isSelected = currentQuestion.type === 'multiple'
+                  ? (answers[currentIndex] || []).includes(index)
+                  : answers[currentIndex] === index
+                const isCorrectOption = currentQuestion.type === 'multiple'
+                  ? (currentQuestion.correctAnswers || []).includes(index)
+                  : currentQuestion.correctAnswer === index
+                const showResult = isReviewMode && answers[currentIndex] !== undefined
+
+                return (
+                  <label
+                    key={index}
+                    className={`w-full p-4 flex items-start gap-3 rounded-lg border-2 transition-all cursor-pointer ${showResult
+                      ? isCorrectOption
+                        ? 'border-green-500 bg-green-50 dark:bg-green-900/30'
+                        : isSelected
+                          ? 'border-red-500 bg-red-50 dark:bg-red-900/30'
+                          : 'border-gray-200 dark:border-gray-600 bg-white dark:bg-gray-800'
+                      : isSelected
+                        ? 'border-primary-500 bg-primary-50 dark:bg-primary-900/30'
+                        : 'border-gray-200 dark:border-gray-600 hover:border-gray-300 dark:hover:border-gray-500 bg-white dark:bg-gray-800'
+                      } text-gray-900 dark:text-white ${isReviewMode ? 'cursor-not-allowed' : ''}`}
+                  >
+                    <input
+                      type={currentQuestion.type === 'multiple' ? 'checkbox' : 'radio'}
+                      name={`question-${currentIndex}`}
+                      checked={isSelected}
+                      onChange={() => !isReviewMode && selectAnswer(currentIndex, index)}
+                      disabled={isReviewMode}
+                      className="mt-1 w-4 h-4 text-primary-600 focus:ring-primary-500 border-gray-300 rounded"
+                    />
+                    <div className="flex-1">
+                      <div className="flex items-start gap-2">
+                        <span className={`flex-shrink-0 w-6 h-6 rounded-full flex items-center justify-center text-sm font-medium ${showResult
+                          ? isCorrectOption
+                            ? 'bg-green-500 text-white'
+                            : isSelected
+                              ? 'bg-red-500 text-white'
+                              : 'bg-gray-200 dark:bg-gray-600 text-gray-600 dark:text-gray-300'
+                          : isSelected
+                            ? 'bg-primary-500 text-white'
+                            : 'bg-gray-200 dark:bg-gray-600 text-gray-600 dark:text-gray-300'
+                          }`}>
+                          {showResult ? (
+                            isCorrectOption ? <Check className="w-4 h-4" /> : isSelected ? <X className="w-4 h-4" /> : String.fromCharCode(65 + index)
+                          ) : (
+                            String.fromCharCode(65 + index)
+                          )}
+                        </span>
+                        <span>{option}</span>
+                      </div>
+                    </div>
+                  </label>
+                )
+              })}
+            </div>
+
+            {isReviewMode && (
+              <div className="mt-4 p-4 bg-blue-50 dark:bg-blue-900/30 rounded-lg">
+                <h4 className="font-semibold text-blue-800 dark:text-blue-300 mb-2 flex items-center gap-2">
+                  <AlertCircle className="w-4 h-4" />
+                  Explanation
+                </h4>
+                <p className="text-blue-700 dark:text-blue-200 text-sm">
+                  {currentQuestion?.explanation}
+                </p>
+              </div>
+            )}
+
+            <div className="flex items-center justify-between mt-6">
+              <button
+                onClick={() => setCurrentIndex(Math.max(0, currentIndex - 1))}
+                disabled={currentIndex === 0}
+                className="flex items-center gap-2 px-4 py-2 bg-gray-100 dark:bg-gray-700 text-gray-700 dark:text-white rounded-lg disabled:opacity-50"
+              >
+                <ChevronLeft className="w-4 h-4" />
+                Previous
+              </button>
+
+              {currentIndex < questions.length - 1 ? (
+                <button
+                  onClick={() => setCurrentIndex(currentIndex + 1)}
+                  className="flex items-center gap-2 btn-primary"
+                >
+                  Next
+                  <ChevronRight className="w-4 h-4" />
+                </button>
+              ) : (
+                <button
+                  onClick={phase === 'review' ? () => navigate('/aws-certification') : submitExam}
+                  className="btn-primary bg-green-600 hover:bg-green-700"
+                >
+                  {phase === 'review' ? 'Back to Practice' : 'Submit Exam'}
+                </button>
+              )}
+            </div>
+          </div>
+        </div>
+
+        <div className="w-64 hidden lg:block">
+          <div className="card sticky top-4">
+            <h3 className="font-semibold mb-3 text-gray-900 dark:text-white">Question Navigator</h3>
+            <div className="grid grid-cols-5 gap-2 mb-4">
+              {questions.map((_, index) => {
+                const isAnswered = answers[index] !== undefined
+                const isCurrent = index === currentIndex
+                const isFlagged = flagged.includes(index)
+                const isCorrectAnswer = isReviewMode && isAnswered && isCorrect(index)
+                const isWrongAnswer = isReviewMode && isAnswered && !isCorrect(index)
+
+                return (
+                  <button
+                    key={index}
+                    onClick={() => setCurrentIndex(index)}
+                    className={`w-10 h-10 rounded-lg font-medium text-sm ${isCurrent
+                      ? 'bg-primary-600 text-white'
+                      : isReviewMode && isCorrectAnswer
+                        ? 'bg-green-100 dark:bg-green-900/50 text-green-700 dark:text-green-400 border-2 border-green-500'
+                        : isReviewMode && isWrongAnswer
+                          ? 'bg-red-100 dark:bg-red-900/50 text-red-700 dark:text-red-400 border-2 border-red-500'
+                          : isAnswered
+                            ? 'bg-green-100 dark:bg-green-900/50 text-green-700 dark:text-green-400'
+                            : isFlagged
+                              ? 'bg-orange-100 dark:bg-orange-900/50 text-orange-700 dark:text-orange-400'
+                              : 'bg-gray-100 dark:bg-gray-700 text-gray-700 dark:text-gray-300'
+                      }`}
+                  >
+                    {index + 1}
+                  </button>
+                )
+              })}
+            </div>
+
+            <div className="text-xs space-y-1 border-t dark:border-gray-700 pt-3 text-gray-600 dark:text-gray-400">
+              <div className="flex items-center gap-2">
+                <div className="w-4 h-4 bg-green-100 dark:bg-green-900/50 rounded" />
+                <span>Answered ({Object.keys(answers).length})</span>
+              </div>
+              <div className="flex items-center gap-2">
+                <div className="w-4 h-4 bg-orange-100 dark:bg-orange-900/50 rounded" />
+                <span>Flagged ({flagged.length})</span>
+              </div>
+              <div className="flex items-center gap-2">
+                <div className="w-4 h-4 bg-gray-100 dark:bg-gray-700 rounded" />
+                <span>Not Visited</span>
+              </div>
+            </div>
+
+            {!isReviewMode && (
+              <button
+                onClick={submitExam}
+                className="btn-primary w-full mt-4 bg-green-600 hover:bg-green-700"
+              >
+                Submit Exam
+              </button>
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+ 

+
+