DP-800 · Open-book technique · Guide + 32 timed drills

Using Microsoft Learn During the Exam

DP-800 is an associate-level role-based exam, so Learn is available to you. That's a real advantage — but it's also the easiest way to lose fifteen minutes you can't spare. This is the guide and the practice for turning it into a weapon rather than a trap.

Rules verified against Microsoft's own exam-experience documentation
⚠ The single most important fact, and almost nobody knows it

Microsoft states it plainly: "Extra time has not been added." And: "The exam timer will continue as you explore Microsoft Learn content."

Every second in the docs comes out of your 90 minutes of question time. Learn access is not a free resource — it is a spend, and you have roughly seven minutes of it before it starts costing you questions. Budget it like money.

1 · The verified rules 2 · Look up or don't 3 · Navigating fast 4 · Target index 5 · 32 drills ★ 6 · Traps 7 · This week's protocol

1 — The verified rules What you actually get, and what's blocked.

Verified against Microsoft Learn — "Exam duration and exam experience". Quotes below are from that page.
QuestionAnswer
Do I get it on DP-800?Yes. "You can access Microsoft Learn as you complete your associate or expert exam." DP-800 is the SQL AI Developer Associate. (Not available on Fundamentals or GitHub exams.)
What can I reach?"Everything in the learn.microsoft.com domain except Q&A, Practice Assessments, and your profile."
Can I use Google or my notes?No. "Web Browsing is restricted to the Microsoft Learn domain." Any other domain shows a "site is blocked" message.
Do I get extra time?No. "Extra time has not been added." "The exam timer will continue as you explore."
How does it appear?"Opens Microsoft Learn in a split screen to the right of the exam question." You can expand to full screen, open multiple tabs, and drag the splitter.
Can I search?Within a page, yes: "you can find content on the current page by pressing Ctrl+F."
One thing I could not confirm — plan for both Microsoft's page highlights Ctrl+F for finding content on the current page but does not explicitly say whether the learn.microsoft.com site search box is usable in the exam window. It may well be — it's part of the domain — but I'm not going to assert it.

So this guide teaches both routes, and section 3 puts the emphasis on navigating by structure. That's the robust skill: it works whether or not search is available, and for a target you can already name it's usually faster than searching anyway.
Two blocked things that will waste your time if you don't know Q&A is blocked. Microsoft Learn Q&A threads often carry the practical answer to an obscure question — and you cannot reach them. Don't go looking.

External links are blocked. Documentation pages link out to GitHub constantly — the DAB schema URL, sample repos, the sqlpackage releases page. Clicking one gets you a blocked-site message and costs you ten seconds and your place. Notice a link's destination before you click it.

2 — Look up, or don't The decision that determines whether this helps or hurts you.

RULE
Name it before you search

You may open the docs only when you can complete this sentence: "I need to find out ___, and knowing it would change my answer."

If you can't name the specific fact, you're not looking something up — you're browsing, and browsing on a running clock is how a comfortable pass becomes a scramble.

✅ Sentence you can complete → go❌ Sentence you can't → don't
"I need the default flag value for REGEXP_LIKE.""I need to understand this question better."
"I need to know whether Export produces a dacpac or a bacpac.""I want to check I'm right."
"I need the exact name of the DMV for fragmentation.""Maybe the docs will tell me which one is better."
"I need the parameter order of sp_invoke_external_rest_endpoint.""I've narrowed it to two and I'm not sure."

Facts, not judgement

Look upNever look up
Exact names — functions, DMVs, catalog views, action groups, roles"Which should I use?" — the docs describe features, they don't choose between them
Parameters and their orderDesign trade-offs — nothing on the page will resolve them
Valid values — flags, enums, optionsAnything you've eliminated to two options by reasoning — trust the reasoning
Defaults — "is it case-sensitive by default?"Concepts — you either know what a latch is or you don't, and a page won't fix it in 90 seconds
Limits — max precision, size caps, compatibility levelQuestions you have no idea about — guess, flag, move
Syntax shape — where a clause goesCase study scenarios — the answer is in the requirements tabs, not the docs
The budget, and why it's this size 90 seconds per lookup. Four or five in the entire exam. That's ~7 minutes of your 90.

Here's the arithmetic that sets the ceiling: your per-question budget is 108 seconds. Every 90-second lookup is most of a question. Five lookups ≈ four questions' worth of time — affordable, because a lookup that flips a wrong answer to a right one is worth more than one extra question read carelessly. Ten lookups is fifteen minutes and you will not finish.
The abandon rule If you haven't found it in 90 seconds, stop. Close the pane, answer from your best reasoning, flag the question, move on.

This is the discipline that matters most, because the failure mode isn't deciding to look something up — it's the sunk-cost spiral. You've spent a minute, so you spend another, because surely it's on the next page. Set the intention before you open the pane: one page, one Ctrl+F, then out.
🔑 Hook: Name it · 90 seconds · one page · then out. If you're reading rather than finding, you've already lost the exchange.
3.1
The shape of learn.microsoft.com

Microsoft Learn is two different things sharing a domain, and knowing which you want halves your time:

TypePath patternUse in the exam?
Reference docs — the technical dictionary/sql/… · /azure/…✅ Almost always this
Training modules — the tutorials you studied/training/modules/…❌ Too long-form. You'll read three screens and find nothing.
The most common time sink Landing in a training module when you wanted a reference page. Modules are written to teach over ten minutes; reference pages are written to answer in ten seconds. If the page has a "Next unit" button at the bottom, you're in the wrong place — back out.

The paths worth memorising

T-SQL functions        learn.microsoft.com/en-us/sql/t-sql/functions/
T-SQL statements       learn.microsoft.com/en-us/sql/t-sql/statements/
T-SQL queries/clauses  learn.microsoft.com/en-us/sql/t-sql/queries/
System stored procs    learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/
System catalog views   learn.microsoft.com/en-us/sql/relational-databases/system-catalog-views/
DMVs                   learn.microsoft.com/en-us/sql/relational-databases/system-dynamic-management-views/
sqlpackage             learn.microsoft.com/en-us/sql/tools/sqlpackage/
Azure SQL Database     learn.microsoft.com/en-us/azure/azure-sql/
Data API Builder       learn.microsoft.com/en-us/azure/data-api-builder/
Azure AI Search        learn.microsoft.com/en-us/azure/search/

You don't need to type these — but recognising the pattern tells you instantly whether a search result is a reference page or a tutorial, before you click it.

3.2
Every reference page has the same five sections

This is the single biggest speed gain available. T-SQL reference pages are rigidly structured, so you can jump straight to the part that answers your question instead of reading from the top.

SectionAnswers
SyntaxWhat are the parameters and in what order?
ArgumentsWhat does each parameter mean, what are its valid values, what's the default?
Return typeWhat comes back — scalar, table, and what data type?
RemarksLimits, caveats, compatibility requirements, gotchas. Underused and often where the answer is.
ExamplesWorking code — useful when the question shows a script fragment
Map your question to a section before you open the page "What are the flag values?" → Arguments. "Does this need compatibility level 170?" → Remarks. "What data type does it return?" → Return type. "Where does this clause go?" → Syntax.

Then use the "In this article" navigation on the right-hand side to jump straight there. One click beats scrolling.

The other two page furnishings that save time

  • The version selector. T-SQL pages carry ?view=sql-server-ver17 (SQL Server 2025) or ver16 (2022) and so on. A 2025-only feature will look like it doesn't exist if you're reading the 2022 view. If a function appears to be missing, check the version dropdown before concluding anything.
  • Breadcrumbs and the left-hand tree. Landed on REGEXP_LIKE and actually wanted the whole family? The left nav shows every sibling function. One click, no search.
🔑 Hook: Syntax = order · Arguments = meanings and defaults · Remarks = limits. Decide which one you need before the page loads.

4 — The target index Pre-load this and most lookups become a single navigation.

The point of this table isn't to memorise URLs. It's so that when a question raises a doubt, you already know which shelf the answer is on — which is the difference between a 30-second lookup and a 3-minute hunt.

If the doubt is about…Go to
A T-SQL function's parameters, flags or return type/sql/t-sql/functions/<name>
Regex functions/sql/t-sql/functions/regular-expressions-functions-transact-sql — the hub, links to all seven
JSON functionsSame functions folder — json-value, json-query, openjson
Vector functions and the VECTOR typeFunctions folder + /sql/relational-databases/vectors/
A clause's position (FOR JSON, OVER, FOR SYSTEM_TIME)/sql/t-sql/queries/ — select-clause pages
A CREATE … statement's options/sql/t-sql/statements/create-<object>-transact-sql
An sp_ procedure/sql/relational-databases/system-stored-procedures/
A sys.dm_ view and its columns/sql/relational-databases/system-dynamic-management-views/
A sys. catalog view/sql/relational-databases/system-catalog-views/
Partitioning, indexes, temporal, ledger, RLS, DDM/sql/relational-databases/ — the conceptual home
Service tiers, DTU/vCore, serverless, Hyperscale/azure/azure-sql/database/
Auditing, Defender, private endpoints, TDE/azure/azure-sql/database/ security section
DAB config keys, CLI, permissions/azure/data-api-builder/
sqlpackage actions and /p: properties/sql/tools/sqlpackage/sqlpackage
AI Search index JSON, field types, vector profiles/azure/search/
Fabric Copilot, capacity and tenant settings/fabric/
The four you're most likely to actually need Based on where your remaining uncertainty sits: the regex hub (newest material), sqlpackage actions (pure rote), the DAB CLI reference (your densest historical miss group), and the system procedures index (the thing your study path genuinely didn't cover). If you only pre-load four locations, make it those.

5 — The drills 32 lookups across four tiers. Reset the timer for each one.

Drill stopwatch — reset before each lookup 00:00
How to run these properly Open learn.microsoft.com in a separate window, sized to about half your screen so it feels like the exam's split pane. For each drill: reset the timer, start it, find the answer, stop it, note your time, then reveal.

The reveal gives both the answer and the path you should have taken — the path matters more than the answer, because the answer is already in your sheets. You are training navigation, not knowledge.

Tier 1 — target 30 seconds A named thing, straight lookup. If these take you a minute, the problem is navigation.

01target 0:30
What data type does JSON_VALUE return?
Reveal
nvarchar(4000)

Page → Return type section. This is why long values need OPENJSON … WITH (col NVARCHAR(MAX)).

/sql/t-sql/functions/json-value-transact-sql
02target 0:30
What are the valid type constraints for ISJSON?
Reveal
VALUE · ARRAY · OBJECT · SCALAR

Page → Arguments.

/sql/t-sql/functions/isjson-transact-sql
03target 0:30
What is the maximum precision of the DECIMAL data type?
Reveal
38

Also on that page: the storage-bytes table (5 / 9 / 13 / 17) worth a glance while you're there.

/sql/t-sql/data-types/decimal-and-numeric-transact-sql
04target 0:30
Which distance metrics does VECTOR_DISTANCE accept?
Reveal
'cosine' · 'euclidean' · 'dot'
/sql/t-sql/functions/vector-distance-transact-sql
05target 0:30
What does the third argument of LAG() do?
Reveal
It supplies the default value returned when there is no row at the requested offset

Without it you get NULL — which is why LAG(Amount, 1, 0) avoids NULL arithmetic.

/sql/t-sql/functions/lag-transact-sql
06target 0:30
How does DENSE_RANK differ from RANK when there are ties?
Reveal
Both give tied rows the same rank; RANK then skips the next value, DENSE_RANK does not

Page → Remarks. Note this is a fact lookup, not a judgement one — legitimate.

/sql/t-sql/functions/dense-rank-transact-sql
07target 0:30
Name the seven regular-expression functions in T-SQL.
Reveal
REGEXP_LIKE · REGEXP_REPLACE · REGEXP_SUBSTR · REGEXP_INSTR · REGEXP_COUNT · REGEXP_MATCHES · REGEXP_SPLIT_TO_TABLE

The hub page lists all seven in one table — learn this URL, it's the fastest route into any of them.

/sql/t-sql/functions/regular-expressions-functions-transact-sql
08target 0:30
What does @@ROWCOUNT return?
Reveal
The number of rows affected by the last statement

"Last statement" is the fragility that makes it a poor choice for a procedure's return code.

/sql/t-sql/functions/rowcount-transact-sql

Tier 2 — target 60 seconds Parameters, flags and defaults. You know the function; you need a detail from inside it.

09target 1:00
What are the four flag values for REGEXP_LIKE, and which is the default?
Reveal
c = case-sensitive (default) · i = case-insensitive · m = multi-line · s = dot matches newline

Page → Arguments → the flags table. Also stated there: an empty string defaults to 'c', and with contradictory flags the last one wins.

/sql/t-sql/functions/regexp-like-transact-sql
10target 1:00
What database compatibility level does REGEXP_LIKE require?
Reveal
170 or above — and it’s the only regex function that needs it

Page → Remarks. This is the classic "the function isn't recognised" answer — and you'd never find it in Syntax or Arguments.

/sql/t-sql/functions/regexp-like-transact-sql
11target 1:00
Which two FOR JSON options cannot be used together?
Reveal
ROOT and WITHOUT_ARRAY_WRAPPER

A root implies a wrapper, so they conflict. Found under the FOR JSON clause page's options section.

/sql/relational-databases/json/format-query-results-as-json-with-for-json-sql-server
12target 1:00
What operations can a Row-Level Security block predicate be applied to?
Reveal
AFTER INSERT · AFTER UPDATE · BEFORE UPDATE · BEFORE DELETE
/sql/relational-databases/security/row-level-security
13target 1:00
Name the masking functions available for Dynamic Data Masking.
Reveal
default() · email() · random(start, end) · partial(prefix, padding, suffix) · datetime() for date and time columns (SQL Server 2022 and later)
/sql/relational-databases/security/dynamic-data-masking
14target 1:00
What are the parameters of sp_invoke_external_rest_endpoint?
Reveal
@url · @method · @headers · @payload · @credential · @timeout · @retry_count · @response OUTPUT

Page → Arguments. Note the credential must be named to match the URL prefix — that's in Remarks.

/sql/relational-databases/system-stored-procedures/sp-invoke-external-rest-endpoint-transact-sql
15target 1:00
In OPENJSON, what data type must a column marked AS JSON be declared as?
Reveal
NVARCHAR(MAX) — no other type is permitted
/sql/t-sql/functions/openjson-transact-sql
16target 1:00
What are the four FOR SYSTEM_TIME sub-clauses besides ALL?
Reveal
AS OF · FROM…TO · BETWEEN…AND · CONTAINED IN

The page also states the boundary inclusivity — FROM's upper bound is exclusive, BETWEEN's is inclusive.

/sql/relational-databases/tables/querying-data-in-a-system-versioned-temporal-table
17target 1:00
What is the default frame when OVER() has an ORDER BY but no explicit frame?
Reveal
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

Note RANGE, not ROWS — the cause of "my running total is wrong on tied dates".

/sql/t-sql/queries/select-over-clause-transact-sql
18target 1:00
What does JSON_MODIFY do when you set a path to NULL in lax mode versus strict mode?
Reveal
lax → deletes the property · strict → sets it to null
/sql/t-sql/functions/json-modify-transact-sql

Tier 3 — target 90 seconds You need to know which shelf first. These are the ones that punish poor navigation.

19target 1:30
Which DMV reports index fragmentation?
Reveal
sys.dm_db_index_physical_stats

Shelf: DMVs → Index Related. The DMV index page groups them by category, which is faster than guessing names.

/sql/relational-databases/system-dynamic-management-views/sys-dm-db-index-physical-stats-transact-sql
20target 1:30
Which catalog view holds partition function boundary values?
Reveal
sys.partition_range_values

Shelf: Catalog views → Partition Function catalog views. Its siblings sys.partition_functions and sys.partition_schemes are right there too.

/sql/relational-databases/system-catalog-views/sys-partition-range-values-transact-sql
21target 1:30
Which sqlpackage action produces a .bacpac, and which consumes one?
Reveal
Export produces a bacpac · Import consumes one

(Extract and Publish are the dacpac pair.) The sqlpackage landing page lists all actions with one-line descriptions — a single page answers the whole family.

/sql/tools/sqlpackage/sqlpackage
22target 1:30
What source types can dab add expose?
Reveal
table · view · stored-procedure

Shelf: Data API Builder → Reference → CLI. Note while you're there that view requires --source.key-fields.

/azure/data-api-builder/reference-command-line-interface
23target 1:30
Which system stored procedure sets a session-scoped key/value pair?
Reveal
sp_set_session_context

This is the mechanism behind RLS multi-tenancy — and note the @read_only parameter, which stops the value being changed later.

/sql/relational-databases/system-stored-procedures/sp-set-session-context-transact-sql
24target 1:30
What field type does Azure AI Search use for a vector field, and what two properties must accompany it?
Reveal
Collection(Edm.Single) — with dimensions and vectorSearchProfile

Edm.Single = single precision = float32. That's the answer to the "what backs a vector?" question.

/azure/search/vector-search-how-to-create-index
25target 1:30
Which audit action group captures failed login attempts?
Reveal
FAILED_DATABASE_AUTHENTICATION_GROUP

Shelf: Security → Auditing → SQL Server Audit Action Groups and Actions. That one page lists every group — bookmark the concept, it answers a whole category.

/sql/relational-databases/security/auditing/sql-server-audit-action-groups-and-actions
26target 1:30
Which DMV shows Azure SQL Database resource consumption for the recent past, and over what window?
Reveal
sys.dm_db_resource_stats — 15-second intervals, roughly the last hour

Database-scoped. Its longer-history sibling is sys.resource_stats in the master database.

/sql/relational-databases/system-dynamic-management-views/sys-dm-db-resource-stats-azure-sql-database
27target 1:30
What is the maximum size of a database in the General Purpose and Business Critical tiers of Azure SQL Database?
Reveal
4 TB — which is why anything larger requires Hyperscale

Shelf: Azure SQL Database → Resource limits. The limits pages are dense tables — Ctrl+F is essential here, don't read them.

/azure/azure-sql/database/resource-limits-vcore-single-databases
28target 1:30
In a full-text index, what are the requirements for the KEY INDEX?
Reveal
A unique, single-column, non-nullable index on the table

Shelf: T-SQL statements → CREATE FULLTEXT INDEX. Also there: one full-text index per table.

/sql/t-sql/statements/create-fulltext-index-transact-sql

Tier 4 — do NOT look these up Practise recognising them. The skill being trained here is restraint.

How to drill this tier Read each one and say out loud: "judgement — answer and move." Then answer it from memory. If you feel the pull to open the docs, notice that feeling — that pull is what costs candidates the exam, and recognising it is the entire exercise.
29answer in 15s
A database will grow to 6 TB and needs read replicas added quickly. Which service tier?
Reveal
Hyperscale — and this is a judgement question

The docs will tell you Hyperscale's limits (drill 27), but they won't tell you it's the answer here. You already know ">4 TB kills GP and BC". Answer and move. The only legitimate lookup would be confirming the 4 TB figure — 30 seconds, not three minutes.

30answer in 15s
Support documents are free-form, lack headings, and shift topics within a single document. Which chunking strategy?
Reveal
Semantic chunking — and there is no page that will tell you this

The docs describe AI_GENERATE_CHUNKS parameters; they do not contain a comparison table of strategies mapped to document characteristics. Looking this up returns nothing and costs you two minutes. This is exactly the category the guide warns about.

31answer in 15s
Administrators must never read a column, but the application must search it by exact value. Which encryption?
Reveal
Always Encrypted with deterministic encryption

Two clauses, both must hold. The docs state what deterministic supports; they won't map the scenario for you. You've drilled this — trust it and move.

32answer in 15s
You have eliminated a question down to two plausible options and can't decide. Do you look it up?
Reveal
No. Pick one, flag it, move on.

Being torn between two options is almost never a fact problem — it's a qualifier problem, and the qualifier is in the stem, not the documentation. Re-read the requirement sentence one more time instead. That is free; the docs are not.

This is the highest-value drill on the page, because this exact moment is where the seven-minute budget gets blown.

6 — The traps

TrapWhat it costsPrevention
Assuming extra time is givenEverything. The timer runs the whole time.Budget 7 minutes total, treat it as spent money
Browsing instead of finding3–5 minutes per occurrenceName the fact before opening the pane
Landing in a training module2+ minutes reading proseIf there's a "Next unit" button, back out — you want /sql/ or /azure/, not /training/
Reading the page top to bottom60–90 secondsCtrl+F, or the "In this article" jump links
Wrong version selectedYou conclude a 2025 feature doesn't existCheck the version selector — ver17 is SQL Server 2025
Clicking an external link10 seconds + losing your placeGitHub and sample repos are blocked. Check where a link points first.
Hunting for Q&A answersDead endQ&A is blocked. So are Practice Assessments and your profile.
The sunk-cost spiral5–10 minutes, and it's the exam-killer90 seconds then out, no exceptions, decided in advance
Looking up a judgement question2 minutes and no answer, because the answer isn't thereTier 4 above — practise recognising the shape
Leaving the pane openHalf your screen, on a text-heavy examClose it after each lookup; use the splitter deliberately
The mindset that gets this right Think of Learn access as four tokens in your pocket. Each token buys you one 90-second lookup. Spending one should feel like a decision — because it is. Candidates who fail with the docs open didn't fail from ignorance; they failed because an unlimited-feeling resource ate a limited clock.

7 — This week's practice protocol

WhenDoPass mark
Session 1 — Wednesday, 20 minTier 1 (drills 1–8) with the timer. Just get familiar with the reference-page layout.Most under 45 seconds
Session 2 — Sunday or Monday, 25 minTiers 2 and 3 (drills 9–28). This is the real work — you're learning which shelf things live on.Tier 2 mostly under 75s · Tier 3 mostly under 2 min
Session 3 — Tuesday, 10 minRe-run any drill that went over target, plus all of Tier 4 out loud.Tier 1 under 30s · Tier 4 answered without hesitation
What "good" looks like by Tuesday You don't need to be fast at all 32. You need three things:
1. Reference pages feel familiar — you know Syntax / Arguments / Return type / Remarks and jump straight to the right one.
2. You know which shelf each kind of thing lives on — functions, procedures, catalog views, DMVs, Azure SQL, DAB, AI Search.
3. You can feel the difference between a fact question and a judgement question without thinking about it.

The third one is worth more than the other two combined.
🔑 The whole guide in one line: Learn access is four 90-second tokens for facts you can name. Everything else — judgement, concepts, being torn between two options — you answer from what you already know, which at 89% is quite a lot.