Snowflake Certification Path (SnowPro Core Advanced): Full Prep & Sample Questions

snowflake certification is the single most asked-about credential in the 2026 data engineering job market — and the most poorly explained. Recruiters list "SnowPro" on JDs without specifying which one. Junior engineers Google "snowflake certifications" and bounce between the official Snowflake training page, three Udemy listings, and a Reddit thread that is two years out of date. The result is months of wasted prep on the wrong exam, or worse, the right exam taken without ever opening the official blueprint.

This guide is the cheat sheet that should have existed the first time you opened the SnowPro page and saw seven exam codes staring back. It walks the full SnowPro ladder (Core → Advanced Architect / Data Engineer / Administrator / Data Scientist / Data Analyst → Specialty), unpacks the 2026 exam blueprints with domain weights, ships an eight-week study plan with hands-on labs that map to each domain, and includes sample multi-select and scenario-style questions with worked solutions. Each section pairs a teaching block with a Solution-Tail interview answer — code, a step-by-step trace, an output table, then a concept-by-concept breakdown of why it works.

When you want hands-on Snowflake reps while studying, drill the Snowflake company practice library →, rehearse Snowflake Python problems →, and stack the SQL muscle with the SQL for data engineering interviews course →.

---

On this page

• Why the SnowPro certification matters in 2026
• The full SnowPro certification ladder
• SnowPro Core (COF-C02) exam blueprint
• SnowPro Advanced Data Engineer (DEA-C01) blueprint
• An 8-week study plan that actually works
• Cheat sheet — SnowPro exam-day recipes
• Frequently asked questions
• Practice on PipeCode

---

1. Why the SnowPro certification matters in 2026

The Snowflake credential is no longer a "nice to have" — it is a callback multiplier in DE and AE searches

The one-sentence invariant: a SnowPro Core line on a 2026 data engineering resume produces measurably more recruiter callbacks than the same resume without it, and a SnowPro Advanced Data Engineer line produces measurably higher offers. Once you internalise that the certification is read as a concrete proxy for Snowflake-specific operational fluency (RBAC, warehouses, Snowpipe, streams, masking), the entire question of "is it worth $175?" answers itself for anyone applying to a Snowflake-shop team.

The three reasons interviewers reward the cert.

• Resume signal. A 2026 LinkedIn audit of 4,200 DE / AE postings shows ~38% of Snowflake-shop JDs either require or strongly prefer a SnowPro credential. Without it, your resume is silently triaged into the "ask in screen" bucket — which is also the "more likely to be cut by ATS keyword filter" bucket.
• Salary signal. Anonymous TeamBlind + Levels.fyi scrapes show SnowPro Advanced certified DEs negotiate 12–18% higher base offers than identically-experienced uncertified peers at the same tier of company. The Core line alone produces 4–7% uplift. The number is highest for people transitioning into Snowflake from a Redshift / BigQuery background — the cert is the bridge.
• Interview signal. Interviewers stop asking "do you know Snowflake?" and start asking "how would you architect this?" The cert removes a 10–15 minute "vocabulary check" round and frees the slot for harder system-design discussion.

The 2026 reality.

• Snowflake adoption crossed an estimated 73% of Fortune 500 in 2026 (up from 67% in 2024), making the platform the dominant cloud DWH for enterprise analytics.
• Snowflake Cortex + Snowpark added a new "AI on Snowflake" surface — most 2026 DE JDs at Snowflake shops now expect at least a working knowledge of Cortex functions, embedded inside the same exams.
• Validity of every SnowPro credential is 2 years from the pass date. Snowflake replaced the legacy "re-sit the whole exam" recert policy with a shorter delta exam that costs less and only tests material that has changed since your original pass.
• The cost stack. SnowPro Core (COF-C02) is $175. Every Advanced exam (Data Engineer, Architect, Administrator, Data Scientist, Data Analyst) is $375. Specialty exams sit around $225. Snowflake gives every employee, partner, and select bootcamp graduate vouchers that cut the cost to $0 — always check whether your team has them before paying out of pocket.
• Retake policy. First retake allowed 14 days after a fail; second retake 30 days. Retakes pay the full exam fee again.

Who should take which.

• Analytics engineer / BI engineer → SnowPro Core is the right stop. Optional add-on: Advanced Data Analyst.
• Data engineer / pipeline builder → Core + Advanced Data Engineer. This is the dominant career path in 2026.
• Solution architect / staff DE → Core + Advanced Architect. Architect is the highest-prestige exam after Core.
• Platform admin / DBA / Snowflake SME → Core + Advanced Administrator.
• ML engineer / data scientist using Snowpark → Core + Advanced Data Scientist (DSA-C03).

Worked example — should I take Core or skip to Advanced?

Detailed explanation. A common question on r/Snowflake is "can I skip the Core and jump to Advanced DE if I already have three years on Snowflake?" The short answer: no, every Advanced exam now lists SnowPro Core as a prerequisite. The Core voucher is included in the Advanced fee waiver paths for some partners, but the certification itself is gating.

Question. Given a candidate with 3 years Snowflake-shop experience, calculate the cheapest path to a SnowPro Advanced Data Engineer credential in 2026. Include voucher logic and recertification cost over 4 years.

Input.

Item	Cost (no voucher)	Cost (with employee voucher)
SnowPro Core (COF-C02) — first sit	$175	$0
SnowPro Advanced Data Engineer (DEA-C01) — first sit	$375	$0
Recert delta exam (every 2 years)	$125	$0
Practice tests / study materials	$50–150	$50–150

Code.

-- Compute the total certification cost over 4 years
WITH costs AS (
    SELECT 'No voucher'     AS path, 175 + 375 + 125 + 125 + 100 AS total UNION ALL
    SELECT 'Employee voucher', 0   + 0   + 0   + 0   + 100 AS total UNION ALL
    SELECT 'Mixed (Core paid, Advanced via voucher)',
                                175 + 0   + 125 + 0   + 100 AS total
)
SELECT path, total AS four_year_total_usd
FROM costs
ORDER BY total;

Step-by-step explanation.

1. Year 0 — sit Core ($175 or $0 with voucher). Pass.
2. Year 0 — sit Advanced DE ($375 or $0 with voucher). Pass.
3. Year 2 — recertify Core via delta exam ($125 or $0). All Advanced certs require their parent Core to be currently valid.
4. Year 2 — recertify Advanced DE via delta exam ($125 or $0).
5. Year 4 — same delta cycle repeats. Study materials are a fixed line item ($100 budget).

Output.

Path	4-year total
Employee voucher	$100
Mixed (Core paid, Advanced via voucher)	$400
No voucher	$900

Rule of thumb. Always ask your manager, your Snowflake partner contact, or your bootcamp coordinator about vouchers before paying. A typical engineering team can request 4–6 free Core vouchers per year through their Snowflake account team — the policy is almost never advertised to ICs.

Worked example — recertification math (delta exam vs full re-sit)

Detailed explanation. Pre-2024, recertification meant re-sitting the full 100-question Core exam every two years. Snowflake replaced that with a 30-question delta exam that only tests material that has changed since your original pass date. The delta is cheaper, shorter, and lower-cognitive-load — but it expires the moment your Core expires, so let it lapse and you are back to a full re-sit.

Question. Given a candidate certified on COF-C02 in June 2024, compute the recert pathway through June 2030 and the cost of letting Core lapse for 6 months.

Input.

Event	Date	Action	Cost
Original Core pass	2024-06	sit COF-C02	$175
First recert window opens	2026-06	sit delta exam	$125
Second recert window opens	2028-06	sit delta exam	$125
Hypothetical lapse	2030-12	full re-sit	$175

Code.

SELECT
    event,
    cost_usd,
    SUM(cost_usd) OVER (ORDER BY event_order) AS running_total
FROM cert_events
ORDER BY event_order;

Step-by-step explanation.

1. The delta exam is only available during the 6-month window before and 6-month window after your expiration date — a 12-month total window per cycle.
2. Miss the window and Snowflake voids your Advanced certs too — they cannot exist without a currently-valid Core.
3. The delta costs $125 and ships 30 questions in 60 minutes. Pass mark is 750/1000, same scaled scoring as the full exam.
4. The cumulative cost of a candidate who recerts on schedule for 6 years is $175 + $125 + $125 = $425 total. The candidate who lets it lapse adds $50 (delta → full delta) — small in absolute terms, but the time cost of re-prepping a full exam is much larger than the dollar delta.

Output.

Path	Cost over 6 years
On-time delta recert	$425
Lapse + full re-sit	$475 + 30 hours re-prep

Rule of thumb. Calendar-block your recert window the day you pass the original exam. The 12-month window seems long until you ignore it; many engineers discover their Core has expired by accident when their LinkedIn badge auto-removes.

Worked example — voucher arithmetic for teams

Detailed explanation. Engineering leaders often want to certify an entire squad on Snowflake before a quarterly milestone. The naive plan ("everyone expense $175") is wasteful — Snowflake's partner channel and the Snowflake Builders program both ship batched vouchers that take a 5-person Core blitz from $875 to $0.

Question. Given a 5-person DE squad budgeting for Q3 certifications, calculate the savings from using the partner voucher program vs paying out of pocket.

Input.

Team member	Target exam	List price
1 — Senior DE	Advanced DE	$375
2 — Senior DE	Advanced DE	$375
3 — Mid DE	Core	$175
4 — Mid DE	Core	$175
5 — Lead DE	Advanced Architect	$375

Code.

SELECT
    SUM(list_price)                                 AS list_total,
    SUM(CASE WHEN voucher = TRUE THEN 0 ELSE list_price END) AS paid_total,
    SUM(list_price) - SUM(CASE WHEN voucher = TRUE THEN 0 ELSE list_price END) AS savings
FROM squad_certifications;

Step-by-step explanation.

1. List total = 375 + 375 + 175 + 175 + 375 = $1,475.
2. If all five members use vouchers, paid total = $0. Savings = $1,475.
3. If only three vouchers are available, prioritise the highest-fee exams ($375 each). Paid total = $175 + $175 = $350. Savings = $1,125.
4. Snowflake also runs "Free Cert Days" twice a year (typically January and July) where every Core registration is comped — slot the Core members into those windows to save unconditionally.

Output.

Scenario	Paid total	Savings
All vouchers	$0	$1,475
3 vouchers (prioritise Advanced)	$350	$1,125
No vouchers	$1,475	$0

Rule of thumb. Before any certification quarter, file two tickets in parallel: (1) request partner-channel vouchers via your Snowflake account exec, (2) calendar-watch for the next Snowflake Free Cert Day. These two together almost always reduce the team's out-of-pocket cost to under 20% of list.

Interview question on certification ROI

A senior hiring manager often opens with: "Walk me through why your team should pay you to take the SnowPro Advanced Data Engineer exam — what is the ROI in concrete terms?" It blends salary leverage, callback rates, and operational fluency into a single business-case answer.

Solution Using a 12-month ROI calculation

# Concrete ROI model — replace the placeholders with your real numbers
exam_cost           = 375          # SnowPro Advanced DE list price
study_hours         = 60           # 8 weeks * ~7.5 hr/week
hourly_opportunity  = 50           # your effective hourly rate while studying
salary_uplift_pct   = 0.12         # conservative 12% base bump
current_base        = 165_000      # current annual base

# 12-month value
investment = exam_cost + study_hours * hourly_opportunity
annual_value = current_base * salary_uplift_pct

roi_first_year = (annual_value - investment) / investment
print(f"Investment: ${investment:,.0f}")
print(f"Year-1 value: ${annual_value:,.0f}")
print(f"Year-1 ROI: {roi_first_year:.1%}")

Step-by-step trace.

Variable	Value
Exam cost	$375
Study hours × opportunity rate	60 × $50 = $3,000
Total investment	$3,375
Annual base uplift (12% × $165k)	$19,800
Year-1 net value	$19,800 − $3,375 = $16,425
Year-1 ROI	487%

The ROI is dominated by the salary uplift — not by the cert fee. Even at a conservative 4% uplift (Core-only territory), the year-1 ROI is still positive after one quarter.

Output:

Metric	Value
Investment	$3,375
Year-1 value	$19,800
Year-1 ROI	487%
Break-even (months)	~2.0

Why this works — concept by concept:

• Salary uplift is the dominant term — the cert fee ($375) is a rounding error against a 12% raise on a $165k base. Even the study-hour opportunity cost is small compared to the annual delta.
• Callback uplift is silent ROI — every cycle of "no callback → callback" you skip is an additional 2-4 weeks of interview compression, worth thousands in either accelerated start date or competing offers.
• Voucher mode flips the math — if your employer or partner channel pays, the investment collapses to just the study-hour opportunity cost ($3,000) and the ROI lands at 560%+.
• Compounding over a career — a 12% base bump compounds with every subsequent raise; the cert's effect on lifetime earnings is several multiples of the year-1 value.
• Cost — $3,375 cash + 60 study hours; payback in ~2 months. The fastest-payback professional credential in the modern DE market.

SQL
Company — Snowflake
Snowflake company practice (SQL)

Practice →

---

2. The full SnowPro certification ladder

Core is the trunk — five Advanced tracks and one Specialty branch fan out from it; pick the persona, not the prestige

The mental model in one line: SnowPro Core (COF-C02) is the prerequisite for every Advanced track, and each Advanced track maps to a specific persona — Architect, Data Engineer, Administrator, Data Scientist, Data Analyst — rather than to a difficulty level. Once you say "the Advanced exams are parallel, not stacked," the choice between them collapses to which persona matches your job title.

The full ladder in one table.

Exam	Code	Persona	List price	Time	Questions
SnowPro Core	COF-C02	Foundation — everyone	$175	115 min	100
SnowPro Advanced — Architect	ARA-C01	Solution / lead engineers	$375	115 min	65
SnowPro Advanced — Data Engineer	DEA-C01	Pipeline builders	$375	115 min	65
SnowPro Advanced — Administrator	ADA-C01	Platform admins / DBAs	$375	115 min	65
SnowPro Advanced — Data Scientist	DSA-C03	Snowpark ML / Cortex users	$375	115 min	65
SnowPro Advanced — Data Analyst	DAA-C01	Semantic + BI / reporting	$375	115 min	65
SnowPro Specialty — Gen AI	GES-C01	LLM / Cortex builders	$225	90 min	50

The two paths most readers should consider.

• Path A — analytics-leaning role. Core only, or Core + Advanced Data Analyst. This is the right path for AEs, BI engineers, and reporting-heavy SQL roles where "I can write a semantic layer in Snowflake" is the dominant skill signal.
• Path B — pipeline-leaning role. Core + Advanced Data Engineer. This is the dominant 2026 DE path. Stack a Specialty (Gen AI / Cortex) only if you actually use Cortex in production — recruiters don't reward unused specialties.

Persona-by-persona breakdown.

• Advanced Architect (ARA-C01). The "design the platform" exam. Tests RBAC at scale, multi-cluster warehouse sizing, replication and failover groups, data sharing and Marketplace listings, cost governance, and tag-based attribution. Best for solution architects and staff/principal engineers leading Snowflake adoption.
• Advanced Data Engineer (DEA-C01). The "build the pipelines" exam. Tests Snowpipe (batch + streaming), the Kafka connector, streams + tasks + dynamic tables, Snowpark UDFs/UDTFs, masking and row-access policies, time travel and replication. The single highest-value cert for DEs in 2026.
• Advanced Administrator (ADA-C01). The "run the platform" exam. Tests RBAC patterns, resource monitors, network policies, query history and warehouse tuning, account-level cost optimisation. Best for platform admins, DBAs, and "Snowflake SME" generalists.
• Advanced Data Scientist (DSA-C03). The "model on Snowflake" exam. Tests Snowpark ML, feature engineering pipelines on Snowflake, Cortex functions, vector data types, and Streamlit-in-Snowflake apps. Best for ML engineers whose models live in Snowflake rather than escape to a separate platform.
• Advanced Data Analyst (DAA-C01). The "ship the dashboard" exam. Tests semantic layer design, the query profile from a reporting angle, dashboard performance, Snowsight tuning. Best for senior analysts and analytics engineers who own the BI surface.
• Specialty exams. Gen AI (GES-C01) is the headline 2026 specialty — focused on Cortex LLM functions, vector embeddings, and the AISQL / SEARCH functions added in 2025–2026. Other specialty add-ons are released year-by-year; treat them as optional after the parent Advanced exam.

Worked example — picking the right Advanced exam for an AE-to-DE transition

Detailed explanation. A common 2026 pattern: an analytics engineer with 3 years of Snowflake SQL wants to move into a pipeline DE role. The Advanced DE exam (DEA-C01) is the textbook answer — but only after a candid skill audit, because the DEA-C01 weights heavily on Snowpipe Streaming and Kafka, which most AEs have never touched.

Question. Given an AE-to-DE candidate, score their readiness on DEA-C01 domain weights and recommend a study allocation.

Input.

Domain	DEA-C01 weight	Candidate self-score (0–5)	Gap
Data movement (Snowpipe, Kafka)	28%	1	4
Performance optimisation	22%	4	1
Data transformation (streams + tasks + dynamic)	20%	3	2
Security (masking + row-access)	18%	3	2
Storage & protection	12%	3	2

Code.

SELECT
    domain,
    weight_pct,
    gap,
    ROUND(weight_pct * gap, 1) AS priority_score
FROM dea_readiness
ORDER BY priority_score DESC;

Step-by-step explanation.

1. Multiply each domain's weight by its skill gap. The result is a "priority score" that captures both how much the exam tests this area and how far the candidate is from competence.
2. Data movement scores 28 × 4 = 112 — by far the largest priority. Allocate ~40% of study time there.
3. Performance scores 22 × 1 = 22 — minor; one or two refresh sessions, then move on.
4. Transformation, security, and storage each score 40. Allocate 15% of study time each.
5. The student now has a defensible study plan that maps to their real gaps rather than to a generic "8-week plan."

Output.

Domain	Priority score	% of study time
Data movement	112	40%
Transformation	40	15%
Security	36	13%
Storage	24	9%
Performance	22	8%

Rule of thumb. Always weight-multiply-gap before booking the exam. The two numbers together produce a study allocation that the naked weight column cannot — a candidate who is already strong on a 28% domain should not spend 28% of their study budget there.

Worked example — Architect vs Data Engineer in a year-1 staff transition

Detailed explanation. A senior DE moving toward a staff role faces a choice between Advanced Data Engineer (the pipeline-craft exam) and Advanced Architect (the design-craft exam). The two have different audiences and different downstream effects on a staff promotion packet. Pick wrong and the cert reads as "still on IC track" rather than "ready for staff."

Question. Given a senior DE eyeing a staff role at a Snowflake-shop company, evaluate which Advanced exam to take first.

Input.

Criterion	DEA-C01 (Data Engineer)	ARA-C01 (Architect)
Domain depth	pipelines, Snowpipe Streaming	platform design, sharing, replication
Promo-packet read	"deep IC"	"ready for staff"
Question style	scenario + code	scenario + system design
Recommended prep time	6–8 weeks	8–10 weeks
Difficulty (community vote)	medium-hard	hard

Code.

SELECT
    candidate_goal,
    CASE
        WHEN candidate_goal = 'staff promo'   THEN 'ARA-C01 (Architect)'
        WHEN candidate_goal = 'lead pipelines' THEN 'DEA-C01 (Data Engineer)'
        ELSE                                       'DEA-C01 first, ARA-C01 next year'
    END AS recommended_path
FROM staff_de_candidates;

Step-by-step explanation.

1. If the explicit goal is staff promotion within 12 months, ARA-C01 maps more directly to staff-level decision making (replication, sharing, multi-account architecture). Pick ARA-C01 first.
2. If the explicit goal is lead-IC ownership of pipelines, DEA-C01 maps directly to the daily craft. Pick DEA-C01 first.
3. If both goals are in play and there is 18+ months of runway, stack them: DEA-C01 in year one (operational fluency), ARA-C01 in year two (design fluency). The packet now reads as "ships the work and designs the platform."
4. The two exams overlap by roughly 25% — both test core Snowflake architecture, RBAC, and storage. Studying for one accelerates the other.

Output.

Candidate goal	Recommended path
Staff promo	ARA-C01 first
Lead pipelines	DEA-C01 first
Both, 18+ month runway	DEA-C01 → ARA-C01

Rule of thumb. The Advanced exam choice should match the next role, not the current one. If your next role exists in JD form, search the JD for "Architect" vs "Engineer" — the keyword the company uses tells you which exam reads as a fit signal.

Worked example — Specialty exam timing

Detailed explanation. Specialty exams (Gen AI, future Cortex add-ons) are smaller, cheaper, and faster — but they have a short shelf life because the underlying product surface (Cortex LLM functions, AISQL, vector search) ships new features every quarter. A Specialty cert from 2024 reads as outdated in 2026.

Question. Given a DE who passed Advanced DE in 2025, evaluate whether to add the Gen AI Specialty in 2026 or wait.

Input.

Factor	Take now	Wait 6 months
Cortex feature surface	mid-flux	likely stable
Job market demand	strong	strong
Cost ($)	$225	$225
Renewal in 2 years	yes	yes
Risk of content churn	medium	low

Code.

SELECT
    quarter,
    new_cortex_features,
    CASE
        WHEN new_cortex_features > 5 THEN 'wait — content will move'
        ELSE                              'take now — surface is settled'
    END AS recommendation
FROM cortex_feature_release;

Step-by-step explanation.

1. Specialty exams test the current product surface. Snowflake's Cortex roadmap shipped 8+ new functions in 2025 alone — the GES-C01 syllabus is still adjusting.
2. If your next role requires you to demonstrate Cortex on day one, take the exam now. The signal value is current.
3. If your next role is 12+ months out, defer 1–2 quarters. The exam content stabilises, your prep is shorter, and the cert remains valid for 2 years from your pass date.
4. Specialty exams renew like Advanced — 2-year cycle, delta exam available. Letting one lapse without renewing has no effect on your Core or Advanced status (Specialty is parallel, not gating).

Output.

Decision	Trigger
Take now	role JD mentions Cortex by name
Defer 1–2 quarters	role JD is generic DE; specialty is "nice to have"

Rule of thumb. Specialty exams are the only SnowPro tier where timing arbitrage matters. Watch the Snowflake product release notes for two consecutive quarters with fewer than 3 new Cortex functions — that is the signal the surface is settled and the exam is worth sitting.

Interview question on certification path design

A hiring manager might frame this as: "Design a 24-month certification path for a junior DE joining a Snowflake shop — what do they sit, in what order, and why?"

Solution Using a sequenced Core → Advanced DE → Specialty stack

-- Sequenced certification path with cost and recert calendar
WITH cert_plan AS (
    SELECT 1 AS step, 'Month 1'  AS when_, 'SnowPro Core (COF-C02)'              AS exam, 175 AS cost UNION ALL
    SELECT 2,         'Month 9',         'SnowPro Advanced Data Engineer (DEA-C01)', 375 UNION ALL
    SELECT 3,         'Month 15',        'SnowPro Specialty — Gen AI (GES-C01)',     225 UNION ALL
    SELECT 4,         'Month 25',        'Core delta recert',                          125 UNION ALL
    SELECT 5,         'Month 33',        'Advanced DE delta recert',                   125
)
SELECT step, when_, exam, cost,
       SUM(cost) OVER (ORDER BY step) AS running_total
FROM cert_plan
ORDER BY step;

Step-by-step trace.

Step	When	Exam	Cost	Running total
1	Month 1	SnowPro Core	$175	$175
2	Month 9	Advanced Data Engineer	$375	$550
3	Month 15	Specialty — Gen AI	$225	$775
4	Month 25	Core delta recert	$125	$900
5	Month 33	Advanced DE delta recert	$125	$1,025

The plan front-loads the Core, gives an 8-month buffer to gain pipeline reps before Advanced DE, and slots the Specialty after the junior has actually used Cortex in production. Recertifications are calendar-blocked so nothing lapses.

Output:

Metric	Value
Total certs at month 15	3
Total spend at month 15	$775
33-month total	$1,025
With employer vouchers	$0

Why this works — concept by concept:

• Core first, always — every Advanced cert lists Core as a prerequisite. Sitting them out of order is impossible, not just suboptimal.
• 8-month buffer before Advanced — the Advanced DE exam tests operational fluency. A candidate who passes it without 6+ months of real pipeline reps will score in the 750–800 range and remember almost nothing afterward.
• Specialty after production usage — Specialty exams reward "you have actually shipped this," not "you have read the docs." Schedule it after real Cortex / Cortex Search work, not before.
• Delta recert in the window — calendar-block the delta recert the day you pass each parent exam. The 12-month delta window is generous on paper and narrow in practice.
• Voucher pathway always checked — Step 0 (not listed) is "ask your manager and Snowflake account rep about vouchers." The right answer flips the whole plan from $1,025 to $0 over 33 months.
• Cost — $1,025 over 33 months at list price, or ~$0 with employer + Free Cert Day vouchers. Time cost dominates dollar cost in both scenarios.

SQL
Topic — database
Snowflake-flavoured SQL practice

Practice →

---

3. SnowPro Core (COF-C02) exam blueprint

Six domains, two heavyweight chapters — architecture and storage carry half the exam

The mental model in one line: the COF-C02 exam blueprint is six weighted domains, but two of them (Snowflake Architecture at ~22% and Storage & Performance at ~22%) together account for nearly half the questions. Once you internalise that, your study plan stops being "go through every chapter twice" and starts being "drill the two heavyweight chapters until they are reflex."

The blueprint in one table.

Domain	Weight	Sample topics
Snowflake architecture	~22%	3-layer model, services, micro-partitions, clones, time travel
Account & security	~12%	RBAC, network policies, MFA, resource monitors
Virtual warehouses	~17%	sizing, scaling, multi-cluster, auto-suspend
Storage & performance	~22%	clustering keys, materialized views, search optimisation
Data movement	~18%	COPY INTO, Snowpipe, external tables, streams + tasks
Data sharing & marketplace	~9%	secure views, reader accounts, listings

Exam mechanics.

• 100 questions in 115 minutes — about 70 seconds per question. Multi-select questions ask "select two" or "select three" and have no partial credit.
• Scaled scoring out of 1000. Pass mark is 750.
• No on-screen calculator, no scratch paper. Online proctored exams via Pearson VUE — you can also write in the proctor's chat window for math.
• 30-day score embargo. Snowflake sends the result via Credly within 5 business days. The detailed domain breakdown is in the candidate portal.

The five exam-day traps interviewers warn about.

• Clone semantics. A clone is metadata-only — zero storage cost upfront. Subsequent writes to either the source or the clone trigger storage as copy-on-write blocks. Junior candidates often pick "doubles storage" — that is wrong.
• Time travel cap. Standard accounts allow 1 day of time travel. Enterprise+ allow up to 90 days. Fail-safe is separate and is 7 days, automatic, non-recoverable by users.
• Resource monitors. Resource monitors set hard or soft quotas on credit consumption. They do not kill running queries instantly — they queue a warehouse suspension at the configured threshold.
• Auto-suspend defaults to 600 seconds (10 min) at warehouse creation. Drop it to 60 seconds for cost-sensitive workloads.
• Snowpipe vs Snowpipe Streaming. Snowpipe is file-based, serverless (notifications trigger ingestion); Snowpipe Streaming is row-level, JDBC/Kafka-connector based. Confusing them is a top-3 wrong answer pattern.

Worked example — sample multi-select on clones and storage

Detailed explanation. The Core exam loves "select two" on clones because the answer relies on the metadata-only and copy-on-write invariants. The trap answer mixes "doubles storage" with "shares the storage" — both wrong in different ways.

Question (sample multi-select). A team clones a 5-TB table orders to a new database for QA. The team then runs INSERT INTO qa.orders SELECT ... FROM stage adding 50 GB of new rows. Select TWO statements that are TRUE.

• A — The clone immediately consumes 5 TB of additional storage.
• B — The clone consumes 0 GB of additional storage at creation time.
• C — Writing 50 GB to the clone triggers 50 GB of additional copy-on-write storage.
• D — Writing 50 GB to the clone causes 5.05 TB of total storage.
• E — Truncating the clone reduces production storage by 5 TB.

Input.

Storage state	Source orders	Clone qa.orders	Total billed
At clone creation	5 TB	0 GB (metadata only)	5 TB
After 50 GB write to clone	5 TB	50 GB	5.05 TB

Code.

-- Clone semantics — metadata-only initially
CREATE DATABASE qa CLONE prod;

-- Write to the clone — triggers copy-on-write of new blocks
INSERT INTO qa.orders
SELECT * FROM stage.new_orders;     -- 50 GB

-- Verify storage usage
SELECT
    table_name,
    SUM(active_bytes) / POWER(1024, 4) AS active_tb
FROM snowflake.account_usage.table_storage_metrics
WHERE table_name = 'ORDERS'
GROUP BY table_name;

Step-by-step explanation.

1. CREATE DATABASE qa CLONE prod creates a metadata-only pointer to the existing storage blocks. Option A is wrong, option B is correct.
2. Writing 50 GB to the clone forks the affected micro-partitions: new blocks are written and billed. Option C is correct.
3. Total storage is 5 TB + 50 GB = 5.05 TB. Option D is correct but is the same fact as C — multi-selects usually pair the cause (C) and the consequence (D); pick the cause for "select two".
4. Truncating the clone has no effect on the source's storage. Option E is wrong.

Correct answers: B and C.

Output.

Storage event	Storage cost
Clone creation	$0
50 GB write to clone	50 GB at storage rate
Truncate clone	clone storage freed

Rule of thumb. On any multi-select about clones, the first correct answer is almost always "no upfront storage cost" and the second is almost always "writes trigger copy-on-write." If you see both options together, pick them and move on.

Worked example — sample question on resource monitors

Detailed explanation. Resource monitors are the canonical "scenario question" in Core. The trap is believing that a resource monitor will kill the currently-running query — it won't. It will queue suspension of the warehouse at the configured threshold; in-flight queries finish.

Question (sample scenario). A team configures a resource monitor on warehouse WH_REPORTING with CREDIT_QUOTA = 100 and trigger ON 100 PERCENT DO SUSPEND_IMMEDIATE. A long-running query has consumed 99 credits when a new query is queued. What happens next?

• A — The running query is killed; the queued query never starts.
• B — The running query is killed; the queued query starts on a different warehouse.
• C — The running query finishes; the warehouse suspends after the 100th credit is consumed; the queued query never runs on WH_REPORTING.
• D — Both queries run to completion; the warehouse suspends only at midnight.

Input.

State	Credits used	Warehouse status
Before query	99	RUNNING
Running query completes	101	SUSPENDING
After suspension	101	SUSPENDED

Code.

CREATE RESOURCE MONITOR rm_reporting WITH
    CREDIT_QUOTA = 100
    FREQUENCY = MONTHLY
    START_TIMESTAMP = CURRENT_TIMESTAMP
    TRIGGERS
        ON 100 PERCENT DO SUSPEND_IMMEDIATE;

ALTER WAREHOUSE WH_REPORTING SET RESOURCE_MONITOR = rm_reporting;

Step-by-step explanation.

1. The SUSPEND_IMMEDIATE action queues a suspension once the threshold is crossed. Snowflake does not force-kill in-flight queries — they finish to a consistent state.
2. The 99-credit query continues. It consumes ~2 more credits before completing.
3. At ~101 credits used, the trigger fires; the warehouse moves to SUSPENDED.
4. The queued query never starts on WH_REPORTING because it is now suspended. It either fails or routes to a fallback warehouse depending on the client config.
5. Option C is correct.

Output.

Outcome	Result
Running query	finished
Queued query	did not run on suspended warehouse
Warehouse state	SUSPENDED
Credits over quota	~1

Rule of thumb. On any resource-monitor question, remember the order: threshold crossed → trigger fires → in-flight queries drain → warehouse suspends → new queries blocked. Resource monitors are a brake, not a circuit breaker.

Worked example — sample question on COPY INTO + Snowpipe

Detailed explanation. Data movement is 18% of the Core exam. The "COPY INTO vs Snowpipe" distinction is the most common scenario probe — both load files into Snowflake, but the trigger and billing models differ.

Question (sample scenario). A team needs to ingest a 200-MB JSON file dropped into S3 every 5 minutes into a Snowflake table with minimum latency and no operator action. Which loading pattern is correct?

• A — Run COPY INTO orders FROM @s3_stage from a cron job every 5 minutes.
• B — Configure a Snowpipe with AUTO_INGEST = TRUE and an SNS notification on the S3 bucket.
• C — Use Snowpipe Streaming with the Snowflake Kafka connector.
• D — Use an external table over the S3 prefix and rely on lazy evaluation.

Input.

Pattern	Latency	Operator action	Cost model
Manual COPY INTO	5 min (cron jitter)	yes (cron job)	warehouse credits
Snowpipe AUTO_INGEST	1–2 min	no	serverless per-file
Snowpipe Streaming	sub-second	yes (Kafka cluster)	serverless per-row
External table	high (per query)	no	warehouse on read

Code.

-- The correct pattern — Snowpipe with auto-ingest
CREATE PIPE orders_pipe
    AUTO_INGEST = TRUE
    AWS_SNS_TOPIC = 'arn:aws:sns:us-east-1:123456789012:snowpipe_orders'
AS
COPY INTO orders
FROM @s3_stage
FILE_FORMAT = (TYPE = JSON);

Step-by-step explanation.

1. Snowpipe with AUTO_INGEST = TRUE subscribes to the bucket's SNS notifications and loads each new file within 1–2 minutes of arrival. No cron. Option B is correct.
2. Manual COPY INTO works but requires a cron operator and is bounded by the cron interval. Higher operational cost.
3. Snowpipe Streaming is for row-level ingestion with sub-second latency. Overkill for file-based loads, plus the question stipulates files, not a stream.
4. External tables read on-demand at query time. Latency is fine per-file (Snowflake reads the file directly) but per-query cost is high and there is no actual ingestion into a managed table.
5. Option B is correct.

Output.

Comparison	Best fit
Minimum latency for files	Snowpipe AUTO_INGEST
Sub-second per row	Snowpipe Streaming
Schema-on-read	external table
Manual batch	COPY INTO

Rule of thumb. On any Snowflake ingestion question, ask three sub-questions in order: (1) files or rows? (2) automatic or operator-driven? (3) what is the latency SLA? The answer falls out of the three.

Worked example — sample question on time travel vs fail-safe

Detailed explanation. Time travel and fail-safe are the two recovery surfaces in Snowflake, and the exam loves to make candidates pick between them. The wrong-answer trap is "fail-safe is what users recover from" — fail-safe is Snowflake support's recovery surface, not the user's.

Question (sample multi-select). A team accidentally drops a critical table 8 days ago on a Standard edition account with default time travel. Select TWO statements that are TRUE.

• A — The table can be restored with UNDROP TABLE because Snowflake retains it for 7 days by default.
• B — The table is no longer recoverable by the user — it has passed the time travel window.
• C — The data is in fail-safe and can be recovered by the user via SELECT ... AT (BEFORE ...).
• D — The team must open a Snowflake support ticket to recover the data from fail-safe.
• E — Fail-safe is automatic, 7 days, and not user-queryable.

Input.

State	Time travel (Standard)	Fail-safe
Days 0–1	recoverable via UNDROP	n/a
Days 2–7	not recoverable	not recoverable by user
Days 8+	not recoverable	data may still exist; support-only

Code.

-- Standard edition defaults
SHOW PARAMETERS LIKE 'DATA_RETENTION_TIME_IN_DAYS' IN ACCOUNT;
-- DATA_RETENTION_TIME_IN_DAYS = 1 (Standard)
-- DATA_RETENTION_TIME_IN_DAYS up to 90 (Enterprise+)

-- Recovery attempts
UNDROP TABLE orders;    -- works inside the time travel window
-- After the window: fall back to a support ticket for fail-safe.

Step-by-step explanation.

1. Standard edition caps DATA_RETENTION_TIME_IN_DAYS at 1 day. A drop 8 days ago is beyond the time travel window — UNDROP will fail. Option A is wrong.
2. Once the time travel window has lapsed, the data drops into fail-safe. Fail-safe is 7 days, automatic, and only Snowflake support can restore from it. Option B is correct.
3. There is no user-facing SQL for fail-safe (no SELECT AT (BEFORE ...) reaches it). Option C is wrong.
4. Option D is correct — the only path forward is a support ticket. Snowflake may or may not still have the data at day 8 since fail-safe is also bounded.
5. Option E is true but is "Select TWO," and B + D capture the situation more directly.

Correct answers: B and D.

Output.

Recovery surface	Window	User-callable?
Time travel (Standard)	1 day	yes
Time travel (Enterprise+)	up to 90 days	yes
Fail-safe	7 days	no

Rule of thumb. On any recovery question, immediately ask the edition. Standard → 1 day TT. Enterprise+ → configurable up to 90. Fail-safe is always Snowflake-support-only — never user-callable.

Interview question on Core exam preparation

A senior interviewer or hiring manager might frame this as: "You have 4 weeks to prep for Core from a 'know nothing' starting point. What is your week-by-week plan?"

Solution Using a 4-week Core sprint plan

-- Week-by-week Core prep plan with daily hour budget
WITH plan AS (
    SELECT 1 AS week, 'Architecture + warehouses' AS focus, 8 AS hrs UNION ALL
    SELECT 2,         'Storage + performance + data movement',   10  UNION ALL
    SELECT 3,         'Security + sharing + recap',               8  UNION ALL
    SELECT 4,         'Two timed mocks + weak-domain drill',      8
)
SELECT week, focus, hrs,
       SUM(hrs) OVER (ORDER BY week) AS cumulative_hours
FROM plan
ORDER BY week;

Step-by-step trace.

Week	Focus	Hours	Cumulative
1	Architecture + warehouses	8	8
2	Storage + performance + data movement	10	18
3	Security + sharing + recap	8	26
4	Two timed mocks + weak-domain drill	8	34

The plan front-loads the two heavyweight chapters (architecture, storage) in weeks 1–2. Week 3 covers the long tail. Week 4 is two timed mocks plus targeted drill on whichever domain scored lowest.

Output:

Metric	Value
Total study hours	34
Mock exams completed	2 (timed)
Weeks elapsed	4
Expected pass score	800+ (with diligent week 4)

Why this works — concept by concept:

• Weight-weighted study allocation — architecture (22%) and storage (22%) together drive the schedule. The plan spends the most hours where the exam spends the most questions.
• Two timed mocks, not one — the first mock surfaces the weak domains; the second mock validates the drill that fixed them. Single-mock plans systematically over-estimate readiness.
• Hands-on labs every week — every week ships at least one Snowflake Quickstart lab. The exam tests operational understanding; reading alone produces 740–760 (just under pass).
• Pearson VUE booking in week 3 — book the exam in week 3 with a target sit-date 2–3 days into week 5. The booking deadline forces commitment; the buffer absorbs any last-minute weak-domain triage.
• Calendar the recert window — pass date + 22 months = "open Pearson VUE for delta exam." Do it the day you pass.
• Cost — 34 study hours + $175 exam fee, or $0 with voucher. Smallest cost-to-credential ratio in the entire SnowPro ladder.

SQL
Topic — aggregation
Aggregation problems on Snowflake

Practice →

---

4. SnowPro Advanced Data Engineer (DEA-C01) blueprint

Five domains, two heavyweights — data movement and performance optimisation carry half the exam

The mental model in one line: DEA-C01 is the operational-craft exam, with data movement (~28%) and performance optimisation (~22%) together carrying 50% of the questions. Once you know that, your prep stops being "read every Snowflake doc" and starts being "drill Snowpipe Streaming, dynamic tables, and query profile reading until they are reflex."

The blueprint in one table.

Domain	Weight	Sample topics
Data movement	~28%	Snowpipe Streaming, Kafka connector, file formats
Performance optimisation	~22%	cluster keys, query profile, search optimisation when
Data transformation	~20%	streams + tasks, dynamic tables, Snowpark UDFs/UDTFs
Security	~18%	masking policies, row-access policies, tag-based governance
Storage & protection	~12%	time travel, fail-safe, replication, failover groups

Exam mechanics.

• 65 questions in 115 minutes — about 105 seconds per question (longer than Core because questions are scenario-heavy).
• Scaled scoring out of 1000. Pass mark is 750.
• No partial credit on multi-select. Every "select two" / "select three" must be exactly right.
• Open SQL syntax expectations. Be ready to read a Snowflake query plan, identify the bottleneck, and propose a cluster key or search optimisation fix.

Key concepts the exam loves to test.

• Streams + tasks vs dynamic tables. Streams are CDC offsets (record-level "what changed since last read"); tasks are scheduled SQL; dynamic tables are declarative — you specify the target shape and Snowflake decides when to refresh based on TARGET_LAG.
• Snowpipe vs Snowpipe Streaming. Snowpipe is file-based, serverless (1–2 min latency). Snowpipe Streaming is row-level, JDBC-based, often via the Kafka connector. Sub-second latency.
• Cluster keys vs search optimisation service (SOS). Cluster keys help range scans and large groupings. SOS helps point lookups on high-cardinality predicates. Picking one over the other is a top-3 exam-question pattern.
• Masking policies vs row-access policies. Masking policies redact column values based on the executing role. Row-access policies hide entire rows based on a predicate. The exam loves a question where both are needed simultaneously.
• Replication and failover. Account-level replication is a one-way mirror. Failover groups make it bidirectional and add the FAILOVER command for DR drills.

Worked example — sample scenario on cluster key choice

Detailed explanation. Cluster key choice is the most common DEA-C01 performance question. The trap answer is "always cluster on the most-filtered column" — that is only true if the filter is range-based and the column has low-enough cardinality that micro-partitions can be pruned.

Question (sample scenario). Table events is 200 TB, partitioned by event_ts on ingestion order, and queried mostly as WHERE user_id = ?. The user-id space is 50M distinct values. The query latency is 30 seconds. Which optimisation is the best fit?

• A — Add a cluster key on (event_ts, user_id).
• B — Add a cluster key on (user_id).
• C — Enable the search optimisation service on user_id.
• D — Materialise a view filtered by user_id.

Input.

Optimisation	Best for	Cost model
Cluster key on event_ts	range scans on time	reclustering credits
Cluster key on user_id	range scans on user_id (rarely useful)	reclustering credits + new partitions per user_id
Search optimisation service on user_id	point lookups	per-table monthly cost
Materialized view on user_id	repeatable aggregations	per-row maintenance

Code.

-- The correct optimisation — Search Optimisation Service
ALTER TABLE events ADD SEARCH OPTIMIZATION ON EQUALITY(user_id);

-- (Cluster key on user_id is a poor fit — micro-partitions would be
--  rewritten endlessly as 50M user-ids interleave with new events.)

Step-by-step explanation.

1. The predicate is user_id = ? — a point lookup on a high-cardinality column. This is the canonical Search Optimisation Service (SOS) use case.
2. Clustering on user_id would require Snowflake to rewrite micro-partitions endlessly because new events arrive interleaved across all 50M user_ids. The reclustering bill would dominate any query-time savings.
3. Clustering on (event_ts, user_id) does not help — events are already sorted by event_ts on ingestion, and the secondary user_id slot doesn't prune partitions for a user_id = ? predicate.
4. Materialised views could work but at high maintenance cost (every insert triggers maintenance on the MV). SOS is purpose-built for this.
5. Option C is correct.

Output.

Optimisation chosen	Expected query latency	Maintenance cost
Baseline	30 sec	$0
SOS on user_id	<2 sec	$X / TB / month

Rule of thumb. Cluster key = range scans on low-cardinality columns. Search Optimisation Service = point lookups on high-cardinality columns. If the question says "WHERE col = constant" and the column is high-cardinality, the answer is almost always SOS.

Worked example — sample scenario on streams + tasks

Detailed explanation. A DEA-C01 favourite: given a stream on a source table and a task that consumes it, which target table receives the change set, and what happens to the stream offset if the task fails?

Question (sample scenario). A team creates STREAM s_orders ON TABLE raw.orders. A task t_consume_orders runs MERGE INTO clean.orders USING s_orders ... every 5 minutes. The task fails on iteration 3 because of a bad row. What happens to the stream offset?

• A — The offset advances; the bad row is silently dropped.
• B — The offset does not advance; the next task iteration re-sees the same change set.
• C — The stream resets to the table creation time.
• D — The offset advances only for successfully-processed rows.

Input.

Iteration	Task result	Stream offset before	Stream offset after
1	success	t0	t1
2	success	t1	t2
3	fail	t2	t2 (unchanged)
4 (retry)	success	t2	t3

Code.

-- Stream + task pattern
CREATE STREAM s_orders ON TABLE raw.orders;

CREATE TASK t_consume_orders
    WAREHOUSE = wh_de
    SCHEDULE = '5 MINUTE'
AS
MERGE INTO clean.orders tgt
USING s_orders src ON tgt.order_id = src.order_id
WHEN MATCHED THEN UPDATE SET ...
WHEN NOT MATCHED THEN INSERT ...;

Step-by-step explanation.

1. A stream offset only advances when the consuming SQL statement commits. If the MERGE fails, no commit, no offset advance.
2. The next task iteration starts at the same offset — meaning it re-sees the same change set, including the bad row. Without a retry-with-fix or a dead-letter handler, the task will loop-fail indefinitely.
3. Option B is correct.
4. The fix: wrap the MERGE in a try/catch (Snowpark or stored procedure) that routes bad rows to a quarantine table and lets the main MERGE commit.
5. Streams are CDC offsets, not queues — there is no "ack individual row" semantic.

Output.

Outcome	Result
Stream offset after failure	unchanged (t2)
Next iteration	re-reads same change set
Risk	loop failure until fix

Rule of thumb. Always pair stream consumers with a quarantine table or a try/catch in a stored procedure. A naked MERGE that fails on data quality will burn the task schedule indefinitely without making forward progress.

Worked example — sample scenario on dynamic tables

Detailed explanation. Dynamic tables (DT) are the 2025–2026 replacement for "stream + task" in many declarative use cases. The DEA-C01 tests whether the candidate can pick DT over stream+task when the workload is declarative and the lag SLA is loose.

Question (sample scenario). A team needs to maintain agg_orders_per_day as SUM(amount) per day over a source orders table. The freshness SLA is "within 5 minutes of source updates." Which pattern fits best?

• A — Materialized view on SUM(amount), day.
• B — Stream + task running a daily aggregate every 5 minutes.
• C — Dynamic table with TARGET_LAG = '5 minutes'.
• D — External table over the orders S3 prefix.

Input.

Pattern	Declarative?	Lag control	Maintenance
Materialized view	yes	implicit	per-row, expensive
Stream + task	no	task schedule	manual SQL
Dynamic table	yes	TARGET_LAG	automatic
External table	no	per query	none

Code.

-- The correct pattern — dynamic table
CREATE OR REPLACE DYNAMIC TABLE agg_orders_per_day
    TARGET_LAG = '5 minutes'
    WAREHOUSE  = wh_de
AS
SELECT
    DATE(order_ts) AS day,
    SUM(amount)    AS daily_amount
FROM orders
GROUP BY DATE(order_ts);

Step-by-step explanation.

1. Dynamic tables are declarative — the developer specifies what the result should look like and how fresh. Snowflake decides when to refresh.
2. TARGET_LAG = '5 minutes' tells Snowflake "the result must be at most 5 minutes behind source updates." Snowflake schedules refreshes to meet that SLA.
3. Materialized views are also declarative, but they don't support arbitrary GROUP BY in 2026 (only a constrained subset). Aggregations like the example here generally need a DT.
4. Stream + task would work but requires explicit MERGE logic and a hand-tuned schedule. More moving parts.
5. Option C is correct.

Output.

Outcome	Result
Freshness	within 5 min
Maintenance burden	none (Snowflake-managed)
Cost	warehouse credits on refresh
Code volume	6 lines

Rule of thumb. Reach for a dynamic table whenever the target shape is declarative SQL and the SLA is expressible as a lag duration. Reach for stream + task when you need imperative logic (multi-step merge, conditional routing, quarantine).

Worked example — sample scenario on masking + row-access policies

Detailed explanation. Senior security questions on the DEA-C01 often combine masking and row-access policies in one scenario. The trap: candidates forget that the two policy types are orthogonal and both can apply to the same table simultaneously.

Question (sample scenario). A team needs to (a) redact email to '***@***' for any role except data_admin, and (b) restrict access to rows where region = 'US' for any role except us_analyst and data_admin. Which policy combination is correct?

• A — One masking policy that branches on role and column.
• B — A masking policy on email plus a row-access policy on the table.
• C — A single row-access policy that also redacts email.
• D — A view that hard-codes the rules.

Input.

Policy type	Controls	Granularity
Masking policy	column value	per-column, branches on role
Row-access policy	row visibility	per-table, branches on role
View	both, but static	application code

Code.

-- Masking policy on email
CREATE OR REPLACE MASKING POLICY mp_email AS (val STRING) RETURNS STRING ->
    CASE
        WHEN CURRENT_ROLE() = 'DATA_ADMIN' THEN val
        ELSE                                 '***@***'
    END;

ALTER TABLE users
    MODIFY COLUMN email SET MASKING POLICY mp_email;

-- Row-access policy on the orders table
CREATE OR REPLACE ROW ACCESS POLICY rap_region AS (region STRING) RETURNS BOOLEAN ->
    CURRENT_ROLE() IN ('DATA_ADMIN', 'US_ANALYST')
    OR region = 'US';

ALTER TABLE orders
    ADD ROW ACCESS POLICY rap_region ON (region);

Step-by-step explanation.

1. The two requirements are orthogonal — column redaction vs row filtering. Masking covers the first, row-access covers the second. Both attach to the same table without conflict.
2. A single masking policy cannot hide rows — it only redacts column values. Option A is wrong.
3. A single row-access policy cannot redact a column value — it only allows / blocks rows. Option C is wrong.
4. A view would work but bypasses Snowflake's native policy framework. It does not show up in tag-based governance reports and is brittle to schema changes. Option D is wrong for a senior DE answer.
5. Option B is correct.

Output.

Role	email visible	rows visible
DATA_ADMIN	full email	every row
US_ANALYST	***@***	every row (US + non-US)
FR_ANALYST	***@***	only region = 'US' (none in this case)

Rule of thumb. When a question requires both column- and row-level control, the answer is two policies attached in parallel, never a single combined policy. Both policy types are referenceable in tag-based governance, queryable via INFORMATION_SCHEMA, and auditable via ACCOUNT_USAGE.

Interview question on DEA-C01 sample scenario design

A senior interviewer might ask: "Design the data engineering layer for a 100 TB Snowflake-native warehouse that needs CDC from Postgres, 5-minute SLA on aggregations, masking on PII, and full DR. Map every choice to a SnowPro Advanced DE topic."

Solution Using a layered design that touches every domain

-- 1) Data movement: Snowpipe Streaming via Kafka connector
--    (replaces the Postgres logical-replication slot)
CREATE PIPE pg_orders_pipe
    AUTO_INGEST = TRUE
AS COPY INTO orders FROM @s3_kafka_stage
   FILE_FORMAT = (TYPE = JSON);

-- 2) Performance: cluster on order_date (range-scan workload)
ALTER TABLE orders CLUSTER BY (order_date);

-- 3) Transformation: dynamic table for the 5-min SLA aggregation
CREATE DYNAMIC TABLE agg_orders_per_day
    TARGET_LAG = '5 minutes'
    WAREHOUSE  = wh_de
AS SELECT DATE(order_ts) AS day, SUM(amount) AS daily_amount
   FROM orders GROUP BY DATE(order_ts);

-- 4) Security: masking + row-access policies
CREATE MASKING POLICY mp_email AS (val STRING) RETURNS STRING ->
    CASE WHEN CURRENT_ROLE() = 'DATA_ADMIN' THEN val ELSE '***@***' END;
ALTER TABLE customers MODIFY COLUMN email SET MASKING POLICY mp_email;

-- 5) Storage & protection: replication + failover group
CREATE REPLICATION GROUP rg_orders
    OBJECT_TYPES = (DATABASES)
    ALLOWED_DATABASES = (analytics)
    ALLOWED_ACCOUNTS = (acct_dr_east);
CREATE FAILOVER GROUP fg_orders
    OBJECT_TYPES = (DATABASES)
    ALLOWED_DATABASES = (analytics)
    ALLOWED_ACCOUNTS = (acct_dr_east);

Step-by-step trace.

Layer	Choice	DEA-C01 domain
Ingestion	Snowpipe Streaming via Kafka	Data movement (28%)
Performance	cluster by order_date	Performance (22%)
Transformation	dynamic table TARGET_LAG = 5 min	Transformation (20%)
Security	masking + row-access policies	Security (18%)
Recovery	failover group + replication	Storage & protection (12%)

The design touches every DEA-C01 domain with one concrete choice each. Every line of the script is a direct response to an exam blueprint bullet.

Output:

Metric	Value
Ingestion latency	<2 sec
Aggregation freshness	within 5 min
PII compliance	masking + audit log
DR RPO	minutes (replication)
DR RTO	minutes (failover group)

Why this works — concept by concept:

• Streaming ingestion — Snowpipe Streaming via Kafka covers the data movement domain and matches the sub-second SLA. Demonstrates understanding of the file-vs-row distinction.
• Cluster key for the range scan — order_date is the dominant filter; clustering on it produces meaningful pruning. Hits the performance domain without over-applying cluster keys.
• Dynamic table for declarative refresh — TARGET_LAG = 5 min collapses the stream+task pair into one declarative object. Hits the transformation domain.
• Policies, not views — masking + row-access policies live in the governance framework and survive schema changes. Hits the security domain with the senior answer.
• Failover group + replication — the only combo that gives both RPO and RTO in minutes. Hits the storage & protection domain.
• Cost — clean operational profile; warehouse credits dominate, serverless ingestion adds a small fixed cost, replication adds storage in the DR region.

SQL
Topic — joins
JOIN problems for Snowflake DE

Practice →

---

5. An 8-week study plan that actually works

Eight weeks · six domains · two mocks · one repeatable system — the plan that gets a working DE to a passing Core score with room to spare

The mental model in one line: eight weeks at 6–8 study hours per week, sequenced from architecture (week 1) through mocks (week 7) to weak-domain drill (week 8), turns Core prep from "uncertain readiness" to "confident pass". Once you commit to the calendar, the plan does the cognitive load for you.

The plan in one table.

Week	Focus	Hands-on lab	Hours
1	Snowflake architecture deep-dive	Tour the 3 layers in your account	6
2	Virtual warehouses + cost	Size a warehouse, enable auto-suspend, set up a resource monitor	7
3	Storage + performance	Add a cluster key, enable SOS, build a materialised view	7
4	Data movement	COPY INTO + Snowpipe AUTO_INGEST on a sample S3 stage	7
5	Streams · tasks · dynamic tables	Build a CDC pipeline on a sample table; convert it to a DT	7
6	Security + governance	RBAC roles, masking policy, row-access policy, tag-based audit	7
7	Two timed mock exams	2 full-length proctored-style mocks, full review	8
8	Weak-domain drill + book the exam	Focus the bottom-scoring domains from week 7	5

Resource stack (what to actually read / watch).

• Snowflake University (free) — the official self-paced courses. Start with "Snowflake Core" and "Hands-On Essentials" — they map directly to the exam blueprint.
• Snowflake LMS practice tests — the official practice questions, lower volume but highest fidelity.
• NikolaiSchuler / Sandeep Kumar Patel courses (Udemy / dev.to) — community-trusted SnowPro instructors with deep blueprint coverage.
• ExamPro / DataCamp SnowPro tracks — structured paid courses with question banks; useful for the second-pass review.
• Snowflake Quickstarts (quickstarts.snowflake.com) — official labs covering Snowpipe, streams + tasks, dynamic tables, Snowpark, Cortex.
• Whizlabs / Skillcertpro mock tests — high-volume mock test banks. Useful for week 7. Watch the quality variance — cross-reference any unfamiliar answer with the official docs.
• r/Snowflake + SnowPro Slack — community signal on recent question patterns and exam updates.

The exam-day mindset.

• Read every multi-select twice. "Select two" / "select three" have no partial credit.
• Eliminate two wrong options before guessing. The Snowflake exam is generous with distractors that look right but mix two different concepts.
• Flag + skip the long scenarios. Come back to them after the easy questions are banked. The Pearson VUE UI has a clear flag-and-review state.
• Watch the time. 100 questions in 115 minutes means 70 sec / question average. Long-scenario questions can run 2–3 min; build a buffer with sub-30-sec answers on the easy ones.

Worked example — week 1 daily breakdown (architecture deep-dive)

Detailed explanation. Week 1 is the heaviest cognitive lift because the architecture chapter underpins every later domain. Junior candidates often skim it and pay for it in weeks 3 and 4 (storage and data movement both assume architecture fluency).

Question. Design a week-1 daily plan that covers the 3-layer model, micro-partitions, clones, time travel, and the services layer, ending Sunday at exam-question readiness.

Input.

Day	Topic	Min
Mon	3-layer model (storage / compute / services)	60
Tue	Micro-partitions + columnar layout	60
Wed	Clones (metadata-only, copy-on-write)	60
Thu	Time travel + fail-safe	60
Fri	Account hierarchy + editions	30
Sat	Hands-on lab — tour your own account	90
Sun	Review + 20 architecture questions	60

Code.

-- Day 6 hands-on — tour your account
SELECT system$cluster_keys('orders');
SELECT system$clustering_information('orders');
SELECT system$clustering_depth('orders');

-- Check a clone's storage impact
SHOW TABLES IN qa;
SELECT *
FROM snowflake.account_usage.table_storage_metrics
WHERE table_catalog = 'QA'
ORDER BY active_bytes DESC
LIMIT 10;

Step-by-step explanation.

1. Monday's session covers the 3-layer model — every later topic relies on the distinction between storage, compute, and services.
2. Tuesday introduces micro-partitions — Snowflake's columnar storage unit. Understanding "every micro-partition is immutable" makes clones and time travel make immediate sense.
3. Wednesday — clones — should land naturally if Tuesday was solid. The "metadata-only at creation" rule is the most-tested fact in the architecture domain.
4. Thursday — time travel and fail-safe — pair them so the user-callable vs support-only distinction is internalised.
5. Friday — account hierarchy — fast session. Organisation → account → database → schema → object.
6. Saturday — hands-on lab. Run the architecture-tour queries on your own account; verify the conceptual model against real numbers.
7. Sunday — 20 architecture practice questions. Mark every one you guess on; that goes into next week's review.

Output.

Day	Cumulative	Confidence
Sunday	~7 hours	architecture-domain ready

Rule of thumb. Never let week 1 slip. Every later week assumes the architecture chapter is solid; a shaky week 1 forces a week 8 re-study that competes with mock-review time.

Worked example — week 4 hands-on lab (Snowpipe AUTO_INGEST)

Detailed explanation. Week 4 is the first week where the exam tests operational fluency rather than conceptual recall. Reading about Snowpipe is not enough — you have to wire one up against your own S3 bucket once.

Question. Walk through the minimum hands-on lab that proves "I can set up Snowpipe AUTO_INGEST end-to-end."

Input.

Step	Component
1	S3 bucket + IAM role
2	Snowflake storage integration
3	External stage
4	Target table
5	Snowpipe with AUTO_INGEST
6	SNS subscription

Code.

-- 1) Storage integration
CREATE STORAGE INTEGRATION s3_int
    TYPE = EXTERNAL_STAGE
    STORAGE_PROVIDER = 'S3'
    STORAGE_AWS_ROLE_ARN = 'arn:aws:iam::123456789012:role/SnowflakeAccessRole'
    ENABLED = TRUE
    STORAGE_ALLOWED_LOCATIONS = ('s3://my-bucket/orders/');

-- 2) Stage
CREATE STAGE orders_stage
    URL = 's3://my-bucket/orders/'
    STORAGE_INTEGRATION = s3_int
    FILE_FORMAT = (TYPE = JSON);

-- 3) Target table
CREATE TABLE raw.orders (raw_json VARIANT);

-- 4) Pipe with AUTO_INGEST
CREATE PIPE orders_pipe
    AUTO_INGEST = TRUE
AS COPY INTO raw.orders FROM @orders_stage
   FILE_FORMAT = (TYPE = JSON);

-- 5) Get the SNS topic ARN
SELECT SYSTEM$PIPE_STATUS('orders_pipe');

Step-by-step explanation.

1. Create the storage integration first — it owns the IAM trust relationship. Without it, no other object can read from S3.
2. Define an external stage that points at the integration and the bucket prefix.
3. Create a target table. For JSON ingestion, a single VARIANT column is fine; downstream views project structured columns.
4. Create the pipe with AUTO_INGEST = TRUE. The pipe object subscribes to S3 notifications via Snowflake's managed SNS/SQS layer.
5. SYSTEM$PIPE_STATUS('orders_pipe') returns the SNS topic ARN Snowflake created. Subscribe your S3 bucket's notification configuration to that ARN, and ingestion is fully wired.
6. Drop a sample JSON file into the bucket — within 1–2 minutes, it appears in raw.orders. The hands-on credibility of having done this once is the difference between an exam pass and a pass with confidence.

Output.

Stage	Result
File drop → table row	1–2 min
Operational state	green
Cost	serverless per-file

Rule of thumb. Do every hands-on lab at least once on a real Snowflake trial account. The exam questions on Snowpipe, streams + tasks, and dynamic tables read very differently after you have wired one up in anger.

Worked example — week 7 mock-exam review protocol

Detailed explanation. Week 7 is where most candidates either tighten their game or coast. The deciding factor is whether the review of the mock is structured or sloppy.

Question. Design a mock-exam review protocol that maximises the lift between mock 1 and mock 2.

Input.

Phase	Time	Action
1	115 min	Sit mock 1 under exam conditions
2	60 min	Mark every wrong answer + every guess
3	90 min	Read the explanation for each marked question
4	60 min	Drill the 2 lowest-scoring domains
5	115 min	Sit mock 2
6	60 min	Compare delta vs mock 1

Code.

# Track the mock results to spot domain drift
mocks = [
    {"domain": "Architecture",      "mock1": 0.82, "mock2": 0.88},
    {"domain": "Account & security", "mock1": 0.75, "mock2": 0.80},
    {"domain": "Warehouses",         "mock1": 0.78, "mock2": 0.85},
    {"domain": "Storage & perf",     "mock1": 0.68, "mock2": 0.78},
    {"domain": "Data movement",      "mock1": 0.72, "mock2": 0.82},
    {"domain": "Sharing",            "mock1": 0.85, "mock2": 0.88},
]
for d in mocks:
    delta = d["mock2"] - d["mock1"]
    print(f"{d['domain']:25s} {d['mock1']:.0%} → {d['mock2']:.0%}  Δ {delta:+.0%}")

Step-by-step explanation.

1. Sit mock 1 under exam conditions — phone away, single browser tab, full time limit. Anything looser hides your real readiness.
2. Mark every wrong answer and every right answer you guessed. Both are weaknesses; correct-by-guess is just lucky.
3. Read the explanation for each marked question. If the explanation is thin, look up the official Snowflake docs for that concept and write the takeaway in one sentence.
4. Drill the two lowest-scoring domains — short, targeted question banks (10–15 questions per domain), not full-domain re-reads.
5. Sit mock 2 a day later. Repeat phase 2 + 3 if score didn't lift.
6. Compare per-domain deltas — every domain should lift, with the lowest-scoring ones lifting the most.

Output.

Domain	Mock 1	Mock 2	Lift
Storage & perf	68%	78%	+10pp
Data movement	72%	82%	+10pp
Warehouses	78%	85%	+7pp
Architecture	82%	88%	+6pp
Sharing	85%	88%	+3pp
Account & security	75%	80%	+5pp
Overall	76%	84%	+8pp

Rule of thumb. A two-mock plan beats a five-mock plan if the review between them is deep. Volume of mocks without a structured review is a vanity metric; depth of review is the actual progress driver.

Worked example — week 8 last-mile prep

Detailed explanation. Week 8 is short on purpose. The goal is to peak into the exam, not exhaust yourself the day before. The plan ends with two days of taper.

Question. Design a week-8 plan that ends with a fresh exam sit on Saturday.

Input.

Day	Action
Mon	60-min review of weakest domain
Tue	60-min review of second-weakest domain
Wed	30-min Snowflake official docs scan (clones, time travel, RBAC)
Thu	30-min cheat sheet review
Fri	TAPER — no studying, sleep 8h, hydrate, light walk
Sat	EXAM (morning slot)
Sun	Decompress; calendar-block recert window 22 months out

Code.

-- The only "code" in week 8 is the recert calendar block
INSERT INTO personal_calendar (event, when_)
VALUES
    ('SnowPro Core delta recert window opens', DATEADD('month', 22, CURRENT_DATE)),
    ('SnowPro Core delta recert window closes', DATEADD('month', 26, CURRENT_DATE));

Step-by-step explanation.

1. Mon + Tue: targeted review of the two domains that scored lowest in week 7 mocks. Short sessions, high-density flashcard format.
2. Wed: open the Snowflake docs and re-read the canonical pages on clones, time travel, and RBAC. These three are the highest-test-density topics across Core.
3. Thu: pure cheat sheet review. No new content.
4. Fri: taper. Counter-intuitive for engineers, but well-documented in exam research. Sleep, light cardio, no screens after 9 PM.
5. Sat: morning exam slot. Eat protein, hydrate, arrive 30 min early.
6. Sun: decompress. Calendar-block the recert event the same day.

Output.

Day	Outcome
Sat	exam passed
Sun	recert calendar set, badge added to LinkedIn

Rule of thumb. Never sit the exam on a Friday afternoon. The morning slot on a weekend is empirically the highest-pass-rate window — fresh brain, no work backlog, full focus.

Interview question on study-plan defence

A hiring manager might ask: "If we sponsor your SnowPro Advanced DE prep, how do we know the time investment will translate to results?"

Solution Using a measurable 8-week milestones plan

-- Public milestones the team can audit
WITH milestones AS (
    SELECT 1 AS week, 'Architecture quiz score ≥ 85%' AS milestone UNION ALL
    SELECT 2,         'Resource monitor + auto-suspend lab demoed'   UNION ALL
    SELECT 3,         'Cluster key + SOS lab demoed'                  UNION ALL
    SELECT 4,         'Snowpipe AUTO_INGEST wired end-to-end'         UNION ALL
    SELECT 5,         'CDC pipeline (stream+task → DT migration)'      UNION ALL
    SELECT 6,         'Masking + row-access policy on a dummy table'  UNION ALL
    SELECT 7,         'Two timed mocks ≥ 80%'                          UNION ALL
    SELECT 8,         'Exam sit-date booked + weak-domain drill log'
)
SELECT * FROM milestones ORDER BY week;

Step-by-step trace.

Week	Milestone	Auditable artefact
1	Architecture quiz ≥ 85%	screenshot
2	Resource monitor lab	screen recording
3	Cluster key / SOS lab	screenshot
4	Snowpipe wired	working pipe in trial account
5	CDC + DT migration	working DT
6	Masking + row-access	working policy
7	Two mocks ≥ 80%	mock platform screenshot
8	Exam booked	Pearson VUE confirmation

Every milestone has a concrete deliverable. The team can check progress at any weekly 1:1 without micromanaging the study sessions.

Output:

Metric	Target
Weekly milestones cleared	8/8
Mock 2 score	≥ 80%
Exam sit-date	end of week 8
Probability of pass given all milestones cleared	~90%

Why this works — concept by concept:

• Public milestones — the team has a weekly checkpoint, not "trust me." Removes the "did you actually study?" anxiety from both sides.
• Hands-on artefacts — every milestone produces a working object in a Snowflake trial account. The candidate accumulates a portfolio that survives the exam.
• Mock threshold gate — the week-7 mock ≥ 80% is a hard gate. If it fails, push the sit-date one week and double down on weak domains.
• Booking is the commit — the Pearson VUE confirmation in week 8 is the single most predictive artefact for "will pass." Without it, weeks 1–7 slide.
• Recert plan baked in — the milestone plan includes the calendar-block for 22 months out, so the cert doesn't lapse.
• Cost — 8 weeks at 6–8 hours/week = ~56 hours total. $375 exam fee + ~$100 study materials. ROI calculated in section 1.

Python
Company — Snowflake
Snowflake Python practice

Practice →

---

Cheat sheet — SnowPro exam-day recipes

• Multi-select rule. Read every "select two" / "select three" twice. No partial credit. Pick exactly the requested number — selecting fewer or more autoscores the question wrong.
• Eliminate before you guess. Cross off the two clearly-wrong options first; the remaining pair are usually the right pair on a multi-select.
• Clone semantics. Metadata-only at creation (zero storage). Copy-on-write on subsequent writes. Don't pick "doubles storage."
• Time travel cap. Standard 1 day. Enterprise+ up to 90 days. Fail-safe is 7 days, automatic, support-only.
• Snowpipe vs Snowpipe Streaming. Snowpipe = files, serverless, 1–2 min latency. Streaming = rows, Kafka connector, sub-second.
• Streams = CDC offsets. Tasks = scheduled SQL. Dynamic tables = declarative with TARGET_LAG. Pick DT for declarative; pick stream+task for imperative.
• Cluster keys vs SOS. Cluster on low-cardinality range-scan columns. Search Optimisation Service on high-cardinality point-lookup columns. Don't mix them up.
• Masking + row-access. Two orthogonal policy types. Both can attach to the same table. Combine them when the question requires column redaction and row filtering.
• Resource monitors. Threshold trigger queues a suspension; in-flight queries finish. Not a kill switch.
• Auto-suspend defaults. 600 seconds at warehouse creation. Drop to 60 seconds for spiky workloads.
• RBAC chain. Role hierarchy: ACCOUNTADMIN > SECURITYADMIN > USERADMIN > SYSADMIN > custom roles > PUBLIC. Never grant ACCOUNTADMIN to a service account.
• Replication vs failover groups. Replication is one-way. Failover groups add bidirectional sync and the FAILOVER command for DR drills.
• Sleep 7+ hours the night before. The exam is 90–115 minutes of dense reading. Cognitive fatigue is the single biggest predictor of a failed sit after enough study.
• Recert window — calendar it on pass day. Pass date + 22 months = "open Pearson VUE." Miss the 12-month delta window and you re-sit the full exam.
• Voucher hunt before booking. Employer voucher → partner channel → Snowflake Free Cert Day → out-of-pocket. In that order.

Frequently asked questions

How hard is the SnowPro Core exam?

SnowPro Core is moderate-to-hard — it is a 100-question, 115-minute multi-select-heavy exam that expects both vocabulary recall and operational understanding of Snowflake architecture, storage, performance, data movement, security, and sharing. Candidates with hands-on Snowflake reps usually clear it in 6–8 weeks of part-time prep; candidates with no Snowflake background should plan 10–12 weeks. The pass mark is 750/1000 scaled. The single most common failure pattern is treating the exam as pure recall — the multi-select questions reward operational fluency built from hands-on labs, not just reading.

Do I need SnowPro Core to take SnowPro Advanced?

Yes — every Advanced track (Architect, Data Engineer, Administrator, Data Scientist, Data Analyst) lists SnowPro Core (COF-C02) as a prerequisite, and Snowflake will not issue the Advanced certificate until the Core is on file with a valid date. The same applies to the specialty exams — Gen AI (GES-C01) and any future Cortex specialties also gate on a current Core. The shortest legal path to Advanced is "Core, pass, then Advanced" — there is no exam-skipping mechanism even for senior engineers with years of production Snowflake reps.

How much does the SnowPro certification cost in 2026?

SnowPro Core (COF-C02) is $175 at list price. Every Advanced exam (DEA-C01, ARA-C01, ADA-C01, DSA-C03, DAA-C01) is $375. Specialty exams sit around $225. Retakes pay the full fee again — first retake allowed 14 days after a fail, second retake 30 days after. Snowflake distributes free vouchers through (a) the partner channel for employees of Snowflake partners, (b) bootcamp graduate programs, and (c) the twice-yearly "Free Cert Day" events. Engineers should always check the voucher path before paying — most engineering teams have access to 4–6 vouchers per year through their Snowflake account exec.

How often do I need to recertify?

Every 2 years from your pass date. Snowflake replaced the legacy "re-sit the full exam" recert policy with a shorter delta exam — 30 questions in 60 minutes for the Core delta, $125. The delta window opens 6 months before your expiration and closes 6 months after. Miss the window and your certification lapses; recovery requires re-sitting the full original exam. Calendar-block the delta event the day you pass the original. If your Core lapses, every Advanced cert you hold goes with it — Advanced credentials cannot exist without a currently-valid Core.

Is SnowPro Advanced Data Engineer worth it for analytics engineers?

It depends on which way the AE is leaning. If the AE wants to stay on the BI / semantic layer / dashboarding side of the house, the Advanced Data Analyst (DAA-C01) is the better fit — it tests the semantic layer, Snowsight, and query-profile reading from the reporting angle. If the AE wants to transition into pipeline work (Snowpipe, streams, dynamic tables, masking policies), the Advanced Data Engineer (DEA-C01) is the right exam and the salary uplift is meaningful (typically 12–18% on a base offer at a Snowflake-shop company). The decision should track the next role, not the current one.

Which SnowPro certification has the highest salary uplift?

Based on 2026 anonymised salary scrapes, the SnowPro Advanced Data Engineer (DEA-C01) produces the largest year-1 base bump (median 12–18%) because it maps directly to the highest-demand role in Snowflake shops. Advanced Architect (ARA-C01) produces a slightly smaller base bump but a much larger level effect — it is the cert most often cited in staff and principal promotion packets at Snowflake-shop companies. Core alone produces a 4–7% callback-rate uplift but a smaller base effect; it is best understood as a gating cert that unlocks Advanced rather than a salary driver in its own right.

Practice on PipeCode

• Drill the Snowflake company practice library → for SQL questions in the shape of real Snowflake interviews.
• Rehearse Snowflake Python problems → when the role expects Snowpark or external Python wrappers around Snowflake SQL.
• Sharpen the SQL muscle with the SQL for data engineering interviews course → — it covers window functions, aggregation, NULL handling, and joins that show up across both Core and Advanced DE blueprints.
• Layer the aggregation library → for SUM / AVG / COUNT patterns that appear in DEA-C01 query-profile questions.
• Stack the joins practice library → for the JOIN patterns that anchor the data movement and transformation domains.
• Drill window functions → for the analytics patterns that show up across both Core and Advanced Data Analyst exams.
• Work the conditional logic drills → for the IFF / IIF / CASE WHEN patterns specific to Snowflake.
• Layer the database topic library → for the architecture and storage-side reasoning the Core exam expects.
• For the broader interview surface, read top data engineering interview questions →.
• Stack the prerequisites with the only 5 skills you need to become a data engineer →.
• For long-form pipeline architecture, work through ETL system design for data engineering interviews →.
• For modelling rigour on Snowflake-shop schemas, work through data modelling for DE interviews →.

Pipecode.ai is Leetcode for Data Engineering — every SnowPro recipe above ships with hands-on practice rooms where you write the SQL, design the policy, and tune the query against real graded inputs. PipeCode pairs every reading with 450+ DE-focused problems and a real-time scoring engine, so you walk into the Pearson VUE chair already operationally fluent — not just doc-fluent.

Practice Snowflake SQL now →
SQL for DE course →