DP-300 Practice Question: Monitor, configure, and optimize database resources
You are monitoring an Azure SQL Database and notice high PAGELATCH waits. What is the most likely cause?
⚠ Common exam trap
DP-300 often tests the confusion between PAGELATCH (in-memory page latch contention) and PAGEIOLATCH (disk I/O waits) or lock waits (LCK_M_*), causing candidates to pick buffer pool or blocking answers.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Concurrent inserts into a table with a clustered index causing last-page contention.
High PAGELATCH waits in Azure SQL Database are most commonly caused by concurrent inserts into a table with a clustered index, leading to last-page contention. Multiple threads trying to insert into the same page serialize on the page latch, causing PAGELATCH waits. This is a classic OLTP pattern where a monotonically increasing key (like an IDENTITY column) causes all inserts to target the last page.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✓
Concurrent inserts into a table with a clustered index causing last-page contention.
Why this is correct
PAGELATCH waits occur when sessions contend for the same in-memory page; with a clustered index, concurrent inserts target the last page, serialising access there. This last-page contention is the specific mechanism producing the high PAGELATCH waits observed, matching the stem's symptom.
- ✗
Insufficient buffer pool size leading to frequent reads from disk.
Why it's wrong here
Insufficient buffer pool causes PAGEIOLATCH waits, where threads wait for pages to be read from storage, whereas PAGELATCH concerns in-memory page contention with no I/O. Memory sizing is tempting because buffer pool pressure is a common Azure SQL concern, and it would be correct when PAGEIOLATCH waits dominate.
- ✗
High CPU usage due to inefficient queries.
Why it's wrong here
PAGELATCH waits arise from concurrent threads contending for the same in-memory page, typically insert hotspots on the last index page, not from CPU pressure; high CPU instead surfaces as SOS_SCHEDULER_YIELD or CXPACKET waits. CPU tuning is tempting because inefficient queries commonly cause performance issues, but they would be the answer for CPU-related wait types.
- ✗
Long-running transactions blocking other queries.
Why it's wrong here
Blocking produces LCK_M_* lock waits, not PAGELATCH, because blocked sessions wait on lock acquisition rather than on the page latch itself. Investigating blocking is tempting since long transactions frequently degrade Azure SQL performance, and it would be correct when the dominant wait type is LCK_M_X or LCK_M_S.
Go deeper
Related to this question
Learn chapter
Optimizing Database Query and Index Performance
Key term
Azure SQL Indexes
Structures in Azure SQL Database that speed up data retrieval by providing quick access paths to rows, similar to a book index.
Key term
Azure SQL Performance Tuning
Azure SQL Performance Tuning is the process of optimizing the speed and efficiency of queries and database operations in Microsoft Azure SQL Database or SQL Managed Instance to reduce latency and improve throughput.
About these practice questions
One of 574 original DP-300 practice questions on Courseiva, each with a full explanation and wrong-answer analysis — not exam dumps or protected exam content. Learn why practice questions differ from exam dumps →
JA
Written and reviewed by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
Last reviewed September 2026 · checked against the official Microsoft exam blueprint
This DP-300 practice question is part of Courseiva's free Microsoft certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the DP-300 exam.