DEV Community: NicheeLab

SnowPro Core scores you out of 1000, and some questions don't count

NicheeLab — Sun, 16 Aug 2026 01:30:40 +0000

Two things about COF-C03 that catch people out.

The passing score is 750 out of 1000, not 75 out of 100. It's a scaled score, so 750 is roughly 75% accuracy but not exactly.

And not every question counts. Some are unscored beta items mixed into the 100, and you can't tell which. There's no question you can safely coast on.

The format: 100 questions, 115 minutes, $175, valid 2 years, Pearson VUE. That's 69 seconds per question.

Where the points actually are

Six domains, and they are not close to even.

Domain	Weight
1. Cloud Data Platform & Architecture	25%
2. Account Access & Security	20%
3. Data Transformation	20%
4. Data Loading & Unloading	10%
5. Data Protection & Data Sharing	10%
6. Performance & Tuning	15%

Architecture and Security are 45% between them. If you're short on time, that's where it goes.

Domain 1: Architecture (25%)

The biggest domain, and most of it comes down to knowing which of the three layers does what. Storage, Compute, Cloud Services. Questions phrased as "which layer handles this operation" show up constantly.

What you need cold:

Micro-partitions: 50-500 MB, columnar, immutable, managed automatically. The immutability is the part people forget, and it's why an UPDATE rewrites partitions.
The three caches: Result Cache, Metadata Cache, Warehouse Cache. Know where each lives and what invalidates it. This is a favorite.
Edition differences: Standard, Enterprise, Business Critical, VPS. Which feature starts at which tier.
Data Marketplace vs Data Exchange, which are easy to blur together.

Domain 2: Account Access & Security (20%)

Mostly RBAC. Know the hierarchy and what each default role can actually do:

ACCOUNTADMIN
├── SECURITYADMIN   manages object grants account-wide
│   └── USERADMIN   creates users and roles
└── SYSADMIN        owns databases and warehouses

PUBLIC               not in the tree above.
                     Automatically granted to every user.

PUBLIC sitting outside that hierarchy is itself testable. It's a pseudo-role every user gets by default, which is why anything granted to PUBLIC is effectively granted to everyone.

The exam also likes asking which role should perform a given task, and the intended answer is usually "the least privileged one that can", not ACCOUNTADMIN.

Also in scope: network policies (IP allowlist and blocklist, and what they apply to), MFA with Duo, and SSO with SCIM provisioning.

Domain 3: Data Transformation (20%)

SQL UDF vs JavaScript UDF vs External Function, and when each is the right pick
Stored procedure execution context across JavaScript, Snowflake Scripting, and Python
Standard View vs Secure View vs Materialized View. Secure Views block the optimizer from certain pushdowns, which is a tradeoff the exam expects you to know.
Streams plus Tasks as the CDC pattern

Domain 6: Performance & Tuning (15%)

Small domain, but this is where the "choose the best option" questions get genuinely hard.

Scale up for one slow query. Scale out for many concurrent queries. Getting this backwards is the single most common mistake, and it comes up more than once.

Also here: reading a Query Profile (spilling, pruning rate, join order), when clustering keys are worth it (tables over 1 TB, high-cardinality columns), and Resource Monitor notify and suspend actions.

Domains 4 and 5 (10% each)

Ten questions each. Know the surface, don't go deep.

For loading: COPY INTO options (ON_ERROR, PURGE, FORCE, MATCH_BY_COLUMN_NAME), Internal vs External stages, Snowpipe auto-ingest via SQS or REST.

For protection: Time Travel is 0 to 90 days depending on edition, Fail-Safe is a fixed 7 days and only Snowflake can access it. That distinction is worth a guaranteed point. Plus Zero-Copy Clone and the Provider / Consumer / Reader Account model for sharing.

Try one

In which scenario is scaling out (a multi-cluster warehouse) most effective?

A. You want to speed up a single very large query
B. You want to eliminate query queuing caused by many concurrent users
C. You want to reduce storage costs
D. You want to extend the Time Travel retention period

Answer

B. Multi-cluster warehouses handle rising concurrency. When queries start queuing, you add clusters to process more of them in parallel. For a single slow query you scale up instead, meaning a larger warehouse size.

A is the trap, and it catches people who read "multi-cluster" as "more power".

We keep 9,900 practice questions across all 11 SnowPro certifications, each with an explanation on every option. Free to work through: nicheelab.com/en/snowflake-exam.

Four tactics for the day

69 seconds per question means you flag and move. Don't burn four minutes on one item.

Multiple response questions tell you how many to pick ("Select 2"). Pick exactly that many.

On "most appropriate" questions, throw out options that are technically correct but not best practice. Being right isn't the bar.

Watch for negation. "Which is NOT correct" appears often enough that misreading one is a realistic way to lose a point.

After you pass

Core is the prerequisite for all five Advanced tracks: Data Engineer, Administrator, Architect, Data Scientist, Security Engineer. Renewal is a separate Recertification exam ($175, 60 questions, 90 minutes). Let it lapse and you sit the full thing again, so start about 6 months out.

We cover all 11 SnowPro exams if you're continuing past Core.

The full breakdown, with a 6-week study plan, is free to read.

Two domains are 53% of the Databricks Data Engineer Associate exam

NicheeLab — Sat, 15 Aug 2026 16:28:46 +0000

Most DEA study plans treat the five exam domains as if they weigh the same. They don't. Databricks publishes the scoring weights, and two domains carry more than half the exam.

45 questions, 90 minutes, 70% to pass. That's 32 correct.

Domain	Weight	Questions
1. Databricks Lakehouse Patform	24%	~11
2. ELT with Spark SQL and lPython	29%	~13
3. Incremental Data Processing	22%	~10
4. Production Pipelines	16%	~7
5. Data Governance	9%	~4

Domains 1 and 2 are 53% of your score. Domain 5 is four questions. Spend your time accordingly.

Domain 2: ELT with Spark SQL and Python (29%)

The heaviest domain, and the one you can't fake. You read code and say what it does.

MERGE INTO is the single highest-value thing to memorize. It shows up here as UPSERT, again in Domain 3 as the CDC pattern, and again in SCD Type 1/2 scenarios. Know the branches exactly, not roughly.

MERGE INTO target t
USING source s
ON t.id = s.id
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *

Also reliably tested:

CTAS (CREATE TABLE AS SELECT) for creating Delta tables
Window functions: ROW_NUMBER, RANK, LAG, LEAD
Python UDFs vs built-in Spark SQL functions. Python UDFs pay serialization overhead. There's usually a question that turns on exactly this.
Nested JSON: the : notation, explode, from_json, schema_of_json
The same operation written both in the DataFrame API and in Spark SQL, including spark.sql()

Domain 1: Lakehouse Platform (24%)

Concepts plus platform mechanics.

All-Purpose vs Job Clusters is guaranteed. Beyond "interactive vs production", know that Job Clusters auto-terminate when the job ends and cost less.

The rest of this domain:

Magic commands (%sql, %python, %md), dbutils.widgets, sharing variables with %run, notebook version history
Git Folders (formerly Repos): branch switching, the PR review flow, which file types are supported
Delta Lake basics: ACID, time travel (DESCRIBE HISTORY, RESTORE), schema evolution (mergeSchema), and the difference between OPTIMIZE and VACUUM

Domain 3: Incremental Data Processing (22%)

This one tests judgment. Which approach fits which situation.

"COPY INTO or Auto Loader?" will be on your exam. COPY INTO for a small, bounded set of files. Auto Loader for continuous ingestion at volume.

For Auto Loader, know Directory Listing vs File Notification mode, plus cloudFiles.inferColumnTypes and cloudFiles.schemaEvolutionMode.

For Structured Streaming, know the output modes (append, complete, update), the triggers (Trigger.availableNow, processingTime), and what checkpoints actually do. Trigger.availableNow vs Trigger.once is a common pairing.

Domain 4: Production Pipelines (16%)

Lakeflow Jobs and Lakeflow Spark Declarative Pipelines.

The Expectations levels come up often enough that the mapping is worth memorizing straight:

What you want	Decorator
Log the violation, keep the row	`@dlt.expect`
Drop the bad row	`@dlt.expect_or_drop`
Stop the pipeline	`@dlt.expect_or_fail`

Also in scope: @dlt.table and @dlt.view, Medallion layering (Bronze, Silver, Gold), task dependencies as a DAG, retry policies, and when you need to reset a streaming checkpoint.

Domain 5: Data Governance (9%)

Four questions. Know what Unity Catalog does, not how to tune it.

The three-level namespace, catalog.schema.table
GRANT and REVOKE syntax, plus the trap that without USAGE you can't reach nested objects
Automatic lineage and what the lineage graph is for
Dynamic views with CURRENT_USER() and IS_MEMBER()

Four things about the question format

Over 70% are "choose the best option". Not "which one is correct". Several options are partly correct and you pick the best one. You'll narrow to two and sit there. That's why knowing each feature's purpose and limits beats knowing it exists.

You never write code from scratch. Questions hand you SQL or PySpark and ask what it outputs, how it behaves, or why it fails. Fill-in-the-blank does show up for MERGE INTO, Auto Loader and Lakeflow syntax, so memorize those skeletons.

Delta Lake is effectively the most-tested topic. It runs through Domain 1 as concepts, Domain 2 as MERGE INTO, and Domain 3 as CDC. OPTIMIZE, VACUUM, Z-ORDER, time travel, schema evolution.

Elimination works. One or two options are usually a clearly unrelated feature, like Unity Catalog offered where the answer is MLflow. Cut to two, then think.

Try one

A pipeline ingests CSV files that keep arriving in a cloud storage landing zone into a Delta table. The file count grows daily and is now past 100,000. You want to process only new files, efficiently. Which approach fits?

A. Schedule COPY INTO, scanning all files each run to find the new ones
B. Auto Loader (cloudFiles) with Structured Streaming, tracking processed files in checkpoints
C. Batch-read the whole zone with spark.read.csv() and find the delta with LEFT ANTI JOIN
D. Reference the CSVs as an external table and filter to the latest data in a view

Answer

B. Auto Loader detects new files and remembers what it already processed, so it doesn't slow down as the count grows. COPY INTO re-scans the file listing every run, which turns into real overhead past 100,000 files. C is expensive. D throws away ACID and time travel.

Worth noticing: A and C both produce the right result. They're wrong on efficiency, not correctness. Most questions on this exam are shaped like that.

That question comes from our practice set. We maintain 6,250 questions across all seven Databricks certifications, with an explanation on every option, and you can work through them free before deciding anything: nicheelab.com/en/databricks-exam.

One scheduling detail

The retake cooldown is 14 days and the exam costs $200, so a failed attempt costs you two weeks and another $200. Worth sitting a full timed mock before you book.

The cert is valid for 2 years. If you pass, Data Engineer Professional and Machine Learning Associate both reuse your Delta Lake, Spark and Unity Catalog knowledge, so take the next one within 2 to 3 months rather than relearning it later. We cover all seven if you're going down that path.

The long version of this breakdown, including an 8-week study plan, is free to read.