Google Cloud Professional Data Engineer (GCP-PDE): 5 Practice Questions on Designing data processing systems

Practice Designing data processing systems for the Google Cloud Professional Data Engineer (GCP-PDE) exam with the 5 questions below. It carries about 22% of the exam score. Every option is explained, so a wrong pick still teaches something.

GCP-PDE Designing data processing systems: 5 practice questions

Google Cloud Professional Data Engineer (GCP-PDE) · Designing data processing systems · 5 questions with answers and explanations

🧭 How Designing data processing systems is tested

Design questions describe a data platform, often across several projects, and ask how to secure, govern or lay it out before any pipeline runs. Service accounts, IAM scope, encryption keys and data protection usually decide. Strong options give each job its own identity with only the access it needs; weaker ones reuse broad default accounts or copy data to work around a permission.

Three things to look for

• Give each pipeline a dedicated service account and grant it roles on the exact datasets and buckets it touches, not on the whole project.
• Keep raw, curated and experimental data in separate datasets or projects so access boundaries can be proven to auditors.
• Customer-managed keys and Sensitive Data Protection answer compliance requirements; check which one the scenario actually asks for.

Question 1 of 5

A retailer builds order tables with Dataform. Each morning the finance team found rows with missing customer IDs and duplicate order IDs that were loaded without warning. The team wants the pipeline to test these rules on every run and surface failures in the run results. What should they add?

ADataform assertions on the tables, such as non-null on customer ID and a unique key on order ID
BA nightly email asking the finance team to open the tables and look for duplicate rows by eye
CA Dataform unit test with mock input rows, which then also checks the real production data on each run
DA larger BigQuery slot reservation, since duplicate rows come from queries running out of capacity
Show answer

✅ Answer: A

Difficulty: applied · Topic: Dataform, BigQuery

Assertions as data quality tests
In Dataform an assertion is a query that finds rows violating a condition; if it returns any rows, the assertion fails. Dataform runs assertions every time it updates the workflow and reports the result in the run logs. Built-in conditions in a table's config include nonNull (columns never null), uniqueKey (key is unique across rows) and rowConditions (custom SQL rules per row). Manual assertions can hold any SQL check.

Where it fits
Assertions validate data that has just been produced, so they catch bad source data and bad joins alike.

Why each option works or fails
• ✓ A. Assertions with non-null and unique key conditions (correct): each run checks the rules on the real output and shows failures in the execution results.
• ✗ B. Manual eyeballing: slow, inconsistent and after the fact, and it does not scale to millions of rows.
• ✗ C. Unit test: a unit test runs the action's SQL against mock inputs and does not inspect production data on a run.
• ✗ D. More slots: duplicates and nulls are data issues, not capacity issues; more compute gives the same wrong rows faster.

Question 2 of 5

A retailer is building a new analytics platform. Raw files come from partners, curated data feeds finance reports, and a data science group experiments with copies of curated tables. Auditors want to prove that experiments cannot change finance data, and developers need freedom in a non-production space. Which layout best meets these goals?

AKeep every environment in one project with a single dataset, and give analysts the project-level BigQuery Data Editor role to keep management simple
BUse one project per analyst so that every person has full control, and copy curated tables into each of those projects every night
CUse separate projects for raw, curated and sandbox data, with dev and prod split too, and grant roles to groups at the dataset or bucket level
DPut all datasets and buckets in one shared project and separate teams by naming prefixes, relying on the people to avoid touching other teams' tables
Show answer

✅ Answer: C

Difficulty: applied · Topic: BigQuery, Cloud Storage, IAM, Resource Manager

Projects as the governance boundary
In Google Cloud the project is the unit for IAM scope, quotas, billing, audit logs and organization-policy inheritance. For data platforms the common pattern is to separate zones (raw, curated, consumption, sandbox) and environments (dev, test, prod) into separate projects, grouped in folders so that policies apply by inheritance.

Why it works for audits
• IAM granted on a prod project or dataset does not leak into the sandbox, so an experiment cannot write to finance tables by accident.
• Granting roles to groups at the dataset or bucket level keeps access reviews short and explainable.
• Cost and audit logs separate naturally per project.

Why each option works or fails
• ✗ A. Single project and dataset: project-level Data Editor lets any analyst change finance tables, so experiments and production share one blast radius.
• ✗ B. A project per analyst: it multiplies copies of curated data, loses central control and leaves nobody accountable for freshness or access.
• ✓ C. (correct): Separate projects per zone and environment with group-based, resource-level roles: finance data lives in a project that experimenters cannot write to, and sandbox work has no effect on production.
• ✗ D. One shared project with prefixes: names are not an access boundary, so any role granted at project level reaches every team's data, which an auditor cannot accept.

Question 3 of 5

A daily BigQuery Data Transfer Service load from a SaaS advertising source failed for three days because of an expired credential. The credential is renewed and the next run works, but the dashboard still has gaps for those three days. What should the data engineer do?

AExport the dashboard data to Cloud Storage and upload the missing days with a manual load job
BStart a backfill for the missed date range on the existing transfer configuration
CDelete the transfer and create a new one, because past dates cannot be requested again
DWait for the regular schedule, which fills older gaps automatically over the following weeks
Show answer

✅ Answer: B

Difficulty: applied

Recovering from gaps
Scheduled transfers load one run's data at a time. If runs fail, the service does not retroactively rebuild missing periods by itself. BigQuery Data Transfer Service lets you initiate data backfills to recover from outages or gaps, specifying the date range to re-request from the source on the same transfer configuration. This keeps schedule, destination and settings as they were.

Considerations
A backfill works only as far as the source still offers that history; check retention limits of the source.

Why each option works or fails
• ✗ A. Manual upload from the dashboard export: it would load derived, possibly incomplete data and bypass the managed connector.
• ✓ B. Backfill on the existing configuration (correct): it re-runs the transfer for the missing dates and fills the gap with no new setup.
• ✗ C. Delete and recreate: backfills exist for exactly this reason, so recreating the transfer adds work and loses the configuration.
• ✗ D. Waiting for the schedule: regular runs load the current period; they do not retroactively load missed days.

Question 4 of 5

A team lands event data from many producers into Cloud Storage for later loading to BigQuery and Spark. Producers' schemas gain new optional fields every few months. Which file format best fits the landing zone?

ACSV, because every tool can open it and the header row documents each column's type
BAvro, because files carry their schema and support adding fields, and both BigQuery and Spark read it
CProprietary binary dumps from each producer's database, because no conversion happens at write time
DPlain text log lines, because the parser can be changed later without touching stored files
Show answer

✅ Answer: B

Difficulty: applied

Choosing a landing format
For a shared lake zone, prefer self-describing, typed, splittable formats. Avro (row-oriented) and Parquet/ORC (columnar) embed their schema in the file, retain data types, compress well and are read natively by BigQuery, Dataflow and Spark. Avro's schema rules allow a new field with a default value to be added, and BigQuery reads the schema from the Avro file when loading; Avro suits write-heavy landing; Parquet suits analytical scans.

Weak choices
CSV and text carry no types or nested structures and break when columns change. Producer-specific binary dumps need that producer's software to read.

Why each option works or fails
• ✗ A. CSV: a header gives column names, not types, and inserting or reordering columns can silently break loaders.
• ✓ B. Avro (correct): it embeds the schema, preserves types, supports adding fields with defaults, and is read by BigQuery and Spark, so evolving producers do not break consumers.
• ✗ C. Proprietary dumps: they can be read only with the source database's tooling, which defeats sharing across engines.
• ✗ D. Plain log text: schema is implicit in parsing code, which creates ambiguity and slows every consumer.

Question 5 of 5

A nightly ELT job moves shipped orders from a staging table into a history table and then deletes them from staging, using separate SQL statements. Twice, a failure between the two statements left rows in both tables, and the next run counted them twice. How should the engineer remove this inconsistency inside BigQuery?

AIncrease the staging table's partition expiration so the stale rows disappear without any explicit delete
BRun the delete first and the insert second, so that a failure leaves rows in neither table until the next night
CWrap the insert and the delete in one multi-statement transaction that commits both changes together or rolls both back
DAdd a second scheduled query to remove duplicates in the history table after the nightly job has finished
Show answer

✅ Answer: C

Difficulty: applied · Topic: BigQuery

Atomic changes across tables
BigQuery multi-statement transactions let a session run mutating statements (insert, update, delete, merge) across multiple tables and then either COMMIT TRANSACTION atomically or ROLLBACK TRANSACTION. Grouping the statements gives ACID guarantees with snapshot isolation for complex multi-stage updates.

Why the order trick fails
Swapping statement order only changes which side is wrong after a crash (data loss instead of duplicates). Atomicity is what removes both failure modes.

Why each option works or fails
• ✗ A. Longer partition expiration: expiration is a retention rule that deletes by age and does not coordinate the two steps.
• ✗ B. Delete first: a failure in between would lose shipped orders from both tables, trading duplicates for data loss.
• ✓ C. One transaction (correct): the history insert and staging delete become a single unit, so a failure rolls both back and no row exists in both places or in neither.
• ✗ D. Deduplication job later: it hides the symptom, but counts between the job and the cleanup are still wrong.

🎯 What to remember

• Use Dataform assertions to test real output data on every run for nulls, duplicates and rule violations.
• Separate projects by data zone and environment, and grant group roles at the narrowest resource, so governance follows the resource hierarchy.
• Use a backfill on the transfer configuration to recover missed runs.
• Use self-describing formats such as Avro or Parquet in a shared landing zone to absorb schema change and stay engine-neutral.
• Use a BigQuery multi-statement transaction when several changes must succeed or fail together.

📊 About this set

Exam: GCP-PDE · 45 questions · 120 minutes · the second largest of 5 domains
This set: 5 applied · 2 scenario, 1 comparison, 1 trade-off, 1 troubleshooting
Topics: Dataform, BigQuery, Cloud Storage, IAM, Resource Manager

🔗 Related practice sets

• All GCP-PDE practice sets
• Every exam on this blog

📚 Beyond this set

More GCP-PDE questions: https://hyunhp.github.io/cert-bank/#exam=GCP-PDE
Study guide: https://hyunhp.github.io/cert-bank/study.html#exam=GCP-PDE

These are original practice questions, not real exam questions, and cert-bank is not affiliated with any certification vendor.

Original practice questions written for this blog, not exam dumps.

Comments