Exam Bundle

A targeted storage or workload change reduces the log-write bottleneck and transaction commit delays in a controlled comparison. That result is evidence for another corrective change: Interpret transaction log I/O and resource governance metrics alongside CPU, data I/O and workload latency before choosing remediation. The alternative problem is: A SQL database reaches high transaction log write utilization but operations increases CPU blindly because it reads only total DTU or vCore usage. The current Granite SaaS issue is instead: An Azure SQL Database watcher account has excessive permissions because an initial deployment granted full database ownership for simple monitoring. Its decisive acceptance evidence would be: The collector still receives required operational observations but a test unauthorized DDL operation by that identity is denied.

A controlled deadlock produces an analysable event file while ordinary Query Store query metrics remain unaffected. That result is evidence for another corrective change: Use an appropriately scoped Extended Events session to capture the needed deadlock or engine diagnostic information safely. The alternative problem is: An operations team assumes Query Store replaces every server-wide Extended Events diagnostic needed for deadlock investigation. The current Granite SaaS issue is instead: An Azure SQL Database watcher account has excessive permissions because an initial deployment granted full database ownership for simple monitoring. Its decisive acceptance evidence would be: The collector still receives required operational observations but a test unauthorized DDL operation by that identity is denied.

The alert remains quiet during known healthy load and fires for a representative sustained blocking or I/O regression. That result is evidence for another corrective change: Define wait-category baselines and threshold rules tied to sustained workload impact rather than raw existence of wait time. The alternative problem is: A monitoring rule alerts on every nonzero wait statistic value and sends constant false alarms even during normal SQL operations. The current Granite SaaS issue is instead: An Azure SQL Database watcher account has excessive permissions because an initial deployment granted full database ownership for simple monitoring. Its decisive acceptance evidence would be: The collector still receives required operational observations but a test unauthorized DDL operation by that identity is denied.

Define a representative baseline for business query latency, CPU, I/O and active sessions across normal and peak workload windows. That relates to a separate SQL administration problem: An Azure SQL application becomes slow after deployment but operations never captured throughput, CPU or latency metrics from the earlier working period. The Granite SaaS requirement is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. That approach does not directly establish the required fix; the requested acceptance evidence is: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

Choose supported source metrics for each SQL deployment model and normalize the measurement interval and units before comparing performance. That relates to a separate SQL administration problem: A production team confuses server-level instance counters from SQL Server on VMs with database-scoped Azure SQL Database metrics and compares unrelated units. The Granite SaaS requirement is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. That approach does not directly establish the required fix; the requested acceptance evidence is: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

Define wait-category baselines and threshold rules tied to sustained workload impact rather than raw existence of wait time. That relates to a separate SQL administration problem: A monitoring rule alerts on every nonzero wait statistic value and sends constant false alarms even during normal SQL operations. The Granite SaaS requirement is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. That approach does not directly establish the required fix; the requested acceptance evidence is: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

A targeted storage or workload change reduces the log-write bottleneck and transaction commit delays in a controlled comparison. That result is evidence for another corrective change: Interpret transaction log I/O and resource governance metrics alongside CPU, data I/O and workload latency before choosing remediation. The alternative problem is: A SQL database reaches high transaction log write utilization but operations increases CPU blindly because it reads only total DTU or vCore usage. The current Granite SaaS issue is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. Its decisive acceptance evidence would be: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

A controlled deadlock produces an analysable event file while ordinary Query Store query metrics remain unaffected. That result is evidence for another corrective change: Use an appropriately scoped Extended Events session to capture the needed deadlock or engine diagnostic information safely. The alternative problem is: An operations team assumes Query Store replaces every server-wide Extended Events diagnostic needed for deadlock investigation. The current Granite SaaS issue is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. Its decisive acceptance evidence would be: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

A controlled failed connection produces a timestamped diagnostic event and the intended alert reaches the operations team. That result is evidence for another corrective change: Configure relevant Azure SQL diagnostic settings and alerts for connection failures, resource pressure and availability signals. The alternative problem is: A managed database shows intermittent connection failures but the monitoring configuration records only successful transaction counts. The current Granite SaaS issue is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. Its decisive acceptance evidence would be: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

Choose supported source metrics for each SQL deployment model and normalize the measurement interval and units before comparing performance. That relates to a separate SQL administration problem: A production team confuses server-level instance counters from SQL Server on VMs with database-scoped Azure SQL Database metrics and compares unrelated units. The Brookside Manufacturing requirement is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. That approach does not directly establish the required fix; the requested acceptance evidence is: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

Use the minimum supported monitoring permissions and separate observability identities from database administration roles. That relates to a separate SQL administration problem: An Azure SQL Database watcher account has excessive permissions because an initial deployment granted full database ownership for simple monitoring. The Brookside Manufacturing requirement is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. That approach does not directly establish the required fix; the requested acceptance evidence is: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

Define a representative baseline for business query latency, CPU, I/O and active sessions across normal and peak workload windows. That relates to a separate SQL administration problem: An Azure SQL application becomes slow after deployment but operations never captured throughput, CPU or latency metrics from the earlier working period. The Brookside Manufacturing requirement is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. That approach does not directly establish the required fix; the requested acceptance evidence is: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

The metric report distinguishes guest-instance and PaaS database measurements with clearly documented source and units. That result is evidence for another corrective change: Choose supported source metrics for each SQL deployment model and normalize the measurement interval and units before comparing performance. The alternative problem is: A production team confuses server-level instance counters from SQL Server on VMs with database-scoped Azure SQL Database metrics and compares unrelated units. The current Brookside Manufacturing issue is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. Its decisive acceptance evidence would be: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

The monitoring view shows short CPU bursts aligned with the application timeout period and identifies the constrained resource. That result is evidence for another corrective change: Inspect suitably granular performance metrics and correlate transient peaks with requests and throttling rather than relying on long averages. The alternative problem is: A CPU dashboard averages one hour of utilization and hides short saturation events that coincide with transaction timeouts. The current Brookside Manufacturing issue is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. Its decisive acceptance evidence would be: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

The alert remains quiet during known healthy load and fires for a representative sustained blocking or I/O regression. That result is evidence for another corrective change: Define wait-category baselines and threshold rules tied to sustained workload impact rather than raw existence of wait time. The alternative problem is: A monitoring rule alerts on every nonzero wait statistic value and sends constant false alarms even during normal SQL operations. The current Brookside Manufacturing issue is instead: A team stores production query traces indefinitely with customer literals in an unrestricted workspace, exposing sensitive data during incident review. Its decisive acceptance evidence would be: Authorized analysts retain the required performance signals while a test reader cannot access customer literals or expired traces.

Compare Query Store plans and runtime statistics to isolate parameter sensitivity and consider a supported plan or query correction. That relates to a separate SQL administration problem: A stored procedure occasionally chooses an inefficient execution plan after parameter changes and the team blindly rebuilds every table index. The Granite SaaS requirement is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. That approach does not directly establish the required fix; the requested acceptance evidence is: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

Rewrite the date condition into a search-argument-friendly range predicate and confirm its semantic correctness. That relates to a separate SQL administration problem: A query performs a string function on an indexed date column in the WHERE predicate and loses partition or index seek efficiency. The Granite SaaS requirement is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. That approach does not directly establish the required fix; the requested acceptance evidence is: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

Inspect actual execution plan memory grants, spill warnings and relevant DMVs before selecting an indexing or query change. That relates to a separate SQL administration problem: A SQL optimizer chooses an expensive sort and spill during a high-volume query but support only monitors aggregate CPU. The Granite SaaS requirement is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. That approach does not directly establish the required fix; the requested acceptance evidence is: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

The rewritten query returns identical rows while the execution plan reads the targeted date range efficiently. That result is evidence for another corrective change: Rewrite the date condition into a search-argument-friendly range predicate and confirm its semantic correctness. The alternative problem is: A query performs a string function on an indexed date column in the WHERE predicate and loses partition or index seek efficiency. The current Granite SaaS issue is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. Its decisive acceptance evidence would be: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

The stabilized query uses an appropriate plan for representative parameter sets and duration variance falls without global index rebuilds. That result is evidence for another corrective change: Compare Query Store plans and runtime statistics to isolate parameter sensitivity and consider a supported plan or query correction. The alternative problem is: A stored procedure occasionally chooses an inefficient execution plan after parameter changes and the team blindly rebuilds every table index. The current Granite SaaS issue is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. Its decisive acceptance evidence would be: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

The updated report returns the same required values while transferring fewer bytes and lowering measured memory demand. That result is evidence for another corrective change: Rewrite the query to project only required columns and review supporting indexes for the access pattern. The alternative problem is: A SQL report selects all columns from a wide transactional table even though it needs only three, causing high memory and network usage. The current Granite SaaS issue is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. Its decisive acceptance evidence would be: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

Evaluate row estimates, join order, predicate placement and suitable indexes using an actual execution plan. That relates to a separate SQL administration problem: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. The Lakeside Research requirement is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. That approach does not directly establish the required fix; the requested acceptance evidence is: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

Inspect actual execution plan memory grants, spill warnings and relevant DMVs before selecting an indexing or query change. That relates to a separate SQL administration problem: A SQL optimizer chooses an expensive sort and spill during a high-volume query but support only monitors aggregate CPU. The Lakeside Research requirement is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. That approach does not directly establish the required fix; the requested acceptance evidence is: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

Compare Query Store plans and runtime statistics to isolate parameter sensitivity and consider a supported plan or query correction. That relates to a separate SQL administration problem: A stored procedure occasionally chooses an inefficient execution plan after parameter changes and the team blindly rebuilds every table index. The Lakeside Research requirement is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. That approach does not directly establish the required fix; the requested acceptance evidence is: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

The actual plan demonstrates corrected cardinality and reduced work for the representative parameter set. That result is evidence for another corrective change: Compare estimated and actual plans with row counts and resource metrics to identify estimation or join-selection problems. The alternative problem is: A SQL DBA sees an estimated execution plan only and concludes a query cannot have cardinality estimation errors at runtime. The current Lakeside Research issue is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. Its decisive acceptance evidence would be: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

Under concurrent load the lead transaction holds locks for less time and dependent requests no longer show sustained blocking. That result is evidence for another corrective change: Shorten the transaction and move the external call outside the critical lock-holding region where consistency rules permit. The alternative problem is: A transaction holds locks while calling an external service and unrelated queries queue behind its long-lived lock scope. The current Lakeside Research issue is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. Its decisive acceptance evidence would be: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

After the targeted I/O or query change physical reads and latency improve while CPU alone is not used as proof. That result is evidence for another corrective change: Correlate wait types with execution plans, physical reads and storage latency to locate the actual I/O bottleneck. The alternative problem is: A query waits on PAGEIOLATCH-related events but the DBA assumes it is always a CPU bottleneck and increases cores. The current Lakeside Research issue is instead: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. Its decisive acceptance evidence would be: The same query has historical plan and runtime records that identify the regressed plan and its performance difference.

Review the reported root-cause context and correlate it with Query Store and platform telemetry before implementing a targeted fix. That relates to a separate SQL administration problem: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. The Lakeside Research requirement is instead: A stored procedure occasionally chooses an inefficient execution plan after parameter changes and the team blindly rebuilds every table index. That approach does not directly establish the required fix; the requested acceptance evidence is: The stabilized query uses an appropriate plan for representative parameter sets and duration variance falls without global index rebuilds.

Correlate wait types with execution plans, physical reads and storage latency to locate the actual I/O bottleneck. That relates to a separate SQL administration problem: A query waits on PAGEIOLATCH-related events but the DBA assumes it is always a CPU bottleneck and increases cores. The Lakeside Research requirement is instead: A stored procedure occasionally chooses an inefficient execution plan after parameter changes and the team blindly rebuilds every table index. That approach does not directly establish the required fix; the requested acceptance evidence is: The stabilized query uses an appropriate plan for representative parameter sets and duration variance falls without global index rebuilds.

Inspect actual execution plan memory grants, spill warnings and relevant DMVs before selecting an indexing or query change. That relates to a separate SQL administration problem: A SQL optimizer chooses an expensive sort and spill during a high-volume query but support only monitors aggregate CPU. The Lakeside Research requirement is instead: A stored procedure occasionally chooses an inefficient execution plan after parameter changes and the team blindly rebuilds every table index. That approach does not directly establish the required fix; the requested acceptance evidence is: The stabilized query uses an appropriate plan for representative parameter sets and duration variance falls without global index rebuilds.

The actual plan demonstrates corrected cardinality and reduced work for the representative parameter set. That result is evidence for another corrective change: Compare estimated and actual plans with row counts and resource metrics to identify estimation or join-selection problems. The alternative problem is: A SQL DBA sees an estimated execution plan only and concludes a query cannot have cardinality estimation errors at runtime. The current Lakeside Research issue is instead: A stored procedure occasionally chooses an inefficient execution plan after parameter changes and the team blindly rebuilds every table index. Its decisive acceptance evidence would be: The stabilized query uses an appropriate plan for representative parameter sets and duration variance falls without global index rebuilds.

The same query has historical plan and runtime records that identify the regressed plan and its performance difference. That result is evidence for another corrective change: Enable and configure Query Store with appropriate capture and retention policies before diagnosing plan performance regressions. The alternative problem is: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. The current Lakeside Research issue is instead: A stored procedure occasionally chooses an inefficient execution plan after parameter changes and the team blindly rebuilds every table index. Its decisive acceptance evidence would be: The stabilized query uses an appropriate plan for representative parameter sets and duration variance falls without global index rebuilds.

The targeted query uses an effective seek or narrower scan with fewer logical reads and acceptable write overhead. That result is evidence for another corrective change: Evaluate an appropriate nonclustered index using predicates, selectivity and maintenance costs, then test the actual execution plan. The alternative problem is: A reporting query scans a very large transaction table for a selective customer ID because the table lacks a useful access path. The current Lakeside Research issue is instead: A stored procedure occasionally chooses an inefficient execution plan after parameter changes and the team blindly rebuilds every table index. Its decisive acceptance evidence would be: The stabilized query uses an appropriate plan for representative parameter sets and duration variance falls without global index rebuilds.