Checking access…

Eureka AI
GCP Architecture
Target Architecture & Advisory
Built on Google Cloud
Executive summary

Recommendation at a glance

Operator location data, demographics and Maps POI already reside in GCP, but in a ; web/app browsing data remains in the on-prem NWK data lake. The current pipeline is duplicated across on-prem and GCP codebases, and daily location×web matching has no reliable, privacy-safe mechanism.

Consolidate on an all-Google lakehouse centred on BigQuery. A nightly on-prem edge job filters ineligible records and ships the raw eligible extract over Interconnect into a restricted GCS bucket. From there, Cloud DLP (Sensitive Data Protection) hashes and tokenizes identifiers using prebuilt de-identification templates, and a Dataflow/Dataproc codebase — orchestrated by Cloud Composer — joins and 24-hour-aggregates the result against location, demographics and Maps POI data ingested zero-copy from the other team's BigQuery project via a listing. Aggregated output is pushed physically to the client and Eureka. The same code path scales to full streaming ingestion of internet browsing data in Phase 3.

One codebase instead of two; a daily match delivered as an SLA-backed product; on-demand analytics answered in minutes inside BigQuery; and structural, not procedural, privacy end to end.

Top highlights

What matters most in this design

1
Location, demographics, POI and browsing data converge in a single governed platform — no more cross-environment engineering.
2
A single Dataflow/Dataproc pipeline replaces today's on-prem vs GCP code fork — and runs unchanged as streaming in Phase 3.
01 · Architecture

Target state on the Google stack

Raw data moves up from the NWK lake into a restricted GCS bucket once a day; location, demographics and Maps POI data are ingested zero-copy from a different team's BigQuery project via a BigQuery Analytics Hub listing; masking, joining and aggregation all happen inside GCP. From there, data leaves GCP in two different ways: a physical, aggregated-only push to the client, and a second, separate zero-copy BigQuery Analytics Hub grant — published directly off the lakehouse — that lets Eureka and vendors query curated or aggregated data directly without a copy ever leaving the platform. Numbers map to the component cards below; red outlines mark the critical builds; red arrows mark physical egress, teal dashed arrows mark zero-copy sharing (both in, from the other team, and out, to Eureka/vendors).

ON-PREM · NWK DATA LAKE Web/App browsing events raw, remains on-prem (interim) 1 Nightly edge job eligibility filter only no masking on-prem raw eligible extract → Parquet 2 · STS over Interconnect GOOGLE CLOUD Location data different team's BigQuery · tokenized Demographics different team's BigQuery 8 Maps POI different team's BigQuery 3 GCS Bucket raw landing · restricted CMEK · SA-only IAM <48h lifecycle 4 Cloud DLP hash + tokenize MDN whitelist / eligibility check Sensitive Data Protection API 5 Dataflow / Dataproc validate · join · aggregate 24-hour window Dataproc Serverless (Spark) bridges → ports to Beam here, §03 7 Analytics Hub Location, Demographics & Maps POI — zero-copy listing from another team's BQ 6 BigQuery Lakehouse curated (tokenized) + gold (24h) — published directly as Analytics Hub listings partitioned + clustered · k-anon Ad-hoc Analytics BigQuery Studio · notebooks on-demand slots · guardrails CONSUMERS 11 Client Delivery S3 push (STS) · SFTP aggregated only 12 Eureka Aggregated data + Analytics Hub listing 13 Vendor Access Aggregated data + Analytics Hub listing 9 Cloud Composer daily DAGs · GCS arrival sensors · SLA alerts · backfills — orchestrates every production job 10 Governance & privacy Dataplex catalog + DQ · Cloud KMS · policy tags · VPC-SC perimeter · CMEK Phase 3: Pub/Sub + Datastream replace the nightly file transfer — same Dataflow/Dataproc code runs streaming (14) Red arrow = physical copy leaves GCP · teal dashed = zero-copy Analytics Hub grant, no data moves
Critical build / configure Eureka / vendor facing GCP managed service On-prem (interim) Enrichment source Red arrow = physical egress Teal dashed = zero-copy Analytics Hub grant
02 · Components

What each section does — and what you must build

Cards outlined in red are the critical path: get these right and everything else is configuration.

1Nightly edge job CRITICAL BUILD

Runs inside the NWK lake. Applies eligibility filters only (opt-outs, ineligible MDNs/URLs) and writes the raw, filtered result as date-partitioned Parquet. No hashing, tokenization or masking happens on-prem — that work moves into GCP (component 4) so there is one governed place it runs, not two.

Spark/SQL filtering job; output contract (schema registry) versioned with the GCP side; no crypto library to maintain on-prem.

2Transfer: STS + Interconnect CRITICAL CONFIG

Storage Transfer Service agent pools pull the nightly Parquet drop over Dedicated/Partner Interconnect into the GCS bucket. Checksummed, resumable, bandwidth-capped. Ingress to GCP is free — you pay only the circuit.

agent pool on-prem, transfer job with manifest + checksum validation, private Google access, alert on missed transfer window.

3GCS Bucket

The landing place for the raw daily extract: a dedicated, tightly-scoped (not a general-purpose data lake bucket). It holds unmasked data only briefly — service-account-only IAM (no human read access), CMEK encryption at rest, VPC-SC perimeter, and a lifecycle policy that force-deletes objects within ~48 hours of successful processing. This short exposure window plus the perimeter is what makes it safe for raw data to touch GCP at all.

dedicated bucket per environment, IAM bound to the Dataflow/Dataproc and DLP service accounts only, Pub/Sub event notification for arrival sensing, automatic lifecycle deletion.

4Cloud DLP — de-identification CRITICAL BUILD

The masking step runs as a : , called from the pipeline immediately after landing. Its de-identification templates provide CryptoHashConfig (one-way hash) and CryptoDeterministicConfig (format-preserving, reversible-with-key tokenization) out of the box, wrapped with a Cloud KMS key — no custom tokenization library to write or maintain. The same stage applies the eligibility/whitelist check against the reference table before anything is written to a durable zone.

DLP de-identification template (deterministic encryption for MDN, using a KMS-wrapped crypto key); whitelist reference table in BQ; pipeline step that calls the DLP API per batch.

5Dataflow / Dataproc — join & aggregate CRITICAL BUILD

Implements the remaining pipeline steps — demographic join, POI lat/long mapping, 24-hour aggregation — on the now-tokenized data. is the target: one codebase that runs batch today and streaming in Phase 3, eliminating the current on-prem vs GCP dual build. If today's pipeline is Spark, runs it unchanged as a Phase 1 bridge while the logic is ported to Beam — see the Dataproc vs Dataflow comparison (§03) for the full trade-off.

Phase 1 — Dataproc Serverless job, no rewrite; Phase 1–2 — port to a Beam Flex Template with unit + pipeline tests, dead-letter outputs, data-quality metrics to Cloud Monitoring.

6BigQuery lakehouse CRITICAL CONFIG

Single analytical home. Zones: (native tables, date-partitioned, clustered on tokenized MDN / geohash — output of DLP + Dataflow/Dataproc), (24h aggregates, k-anonymity enforced). The GCP↔on-prem daily match is a plain BQ join on the shared token; the raw zone no longer persists here since raw data lives only briefly in the GCS bucket (component 3). The lakehouse also publishes curated and gold zones to Eureka (component 12) and vendors (component 13) — no separate sharing box in between.

dataset layout per zone/environment, partition expiry, policy tags on sensitive columns, authorized views for consumers, one Analytics Hub listing per consumer (Eureka, each vendor) published straight off this dataset.

7BigQuery Analytics Hub — cross-team ingestion CRITICAL BUILD

Location data, demographics and Maps POI are owned and maintained by a in their own BigQuery project — this pipeline doesn't copy or re-host that data. Instead, that team exposes it as a , and Dataflow/Dataproc (component 5) subscribes to the listing and reads it directly for the join and aggregation step, zero-copy. There's nothing to build on the source side beyond agreeing the listing's schema and refresh cadence with the owning team; this pipeline only needs a subscription and read access on its own billing project.

subscribe to the owning team's data exchange listing, grant the Dataflow/Dataproc service account read access on the subscribed dataset, agree refresh cadence/SLA with the source team, schema-change alerting.

8Maps POI enrichment

Maps POI reference data (POI-to-lat/long mapping) also lives in the other team's BigQuery project, refreshed there from the Google Maps Places API, and reaches this pipeline through the same Analytics Hub listing as location data and demographics (component 7) — not a separate build here.

confirm Places-licensing terms carry through the shared listing; no ingestion job to write on this side.

9Cloud Composer CRITICAL CONFIG

Owns every production schedule: waits for the on-prem drop, runs DLP de-identification, runs Dataflow/Dataproc, runs BQ aggregate SQL, validates, publishes both to Client Delivery and to the Analytics Hub listings. SLAs, retries, backfill, and alerting live here — not in cron scripts.

one DAG per product (daily match, POI refresh, client delivery, Analytics Hub publish), arrival sensors, SLA-miss alerts to chat/email, backfill runbook.

10Governance & privacy layer CRITICAL CONFIG

Dataplex (catalog, lineage, data quality), Cloud KMS (DLP crypto keys, CMEK), policy tags (column-level access), VPC Service Controls (perimeter so data can't be exfiltrated even by a compromised credential, and so the GCS bucket can never be reached from outside the pipeline's service accounts).

VPC-SC perimeter first (before the GCS bucket goes live), KMS key rotation, Dataplex DQ rules on curated zone, policy-tag taxonomy that also governs Analytics Hub listing eligibility.

11Client Delivery CRITICAL BUILD

The data the operator's hedge-fund clients receive through this path is the 24-hour, k-anonymous gold-zone aggregate — never row-level or tokenized data, no exceptions. Delivered per-fund, once daily: via Storage Transfer Service (GCS→S3 is a native STS job type), or for clients who require it. This is the route for clients without a GCP footprint of their own; clients who do have one are better served by component 13.

STS S3 transfer job per fund (or shared job, per-fund prefix); SFTP push job (Cloud Run + paramiko/similar) for SFTP-only clients; delivery manifest + checksum in the completion notice.

12Eureka Delivery

Eureka builds and operates the client-facing dashboards, so Eureka needs its own access to the lakehouse — via a listing published directly off the lakehouse (component 6), the recommended default: zero-copy, revocable, and able to carry gold (and, where justified, curated) data without any file ever moving. No separate infrastructure to build beyond the listing itself.

Eureka-facing listing on the lakehouse's data exchange (component 6), scoped to gold by default; grant curated access only per documented need.

13Vendor Access

The same Analytics Hub mechanism, extended to who operate their own GCP project — hedge funds, distribution partners, the Omni product line. Rather than standing up a bespoke S3/SFTP feed per vendor, each gets its own revocable listing off the lakehouse (component 6), which can be gold-only or, for vetted partners with a signed data agreement, curated-level. This is the preferred path for any consumer that already lives in GCP; Client Delivery (component 11) remains the fallback for those who don't.

one listing per vendor with its own entitlement and audit trail; default gold-only, curated by exception with sign-off.

14Phase 3: streaming ingestion

When internet browsing data moves in fully: Pub/Sub (events) or Datastream (CDC) feed the same Dataflow/Dataproc code in streaming mode, writing via the BQ Storage Write API. Nightly batch becomes just another window size; DLP de-identification and all delivery paths are unchanged.

topic/schema registry, streaming Flex Template deployment, backfill of history via STS, dual-run validation before on-prem ETL retirement.
03 · Justification

Why this is the right architecture

Four principles drive the design, and every rejected alternative fails at least one of them.

Data gravity, respected

  • Location, demographics and Maps POI data (large, sensitive, already in a different team's BQ project) never moves — Dataflow/Dataproc reads it zero-copy via an Analytics Hub listing. Only the raw eligible browsing extract travels up, into a restricted GCS bucket — nothing sensitive travels back down.
  • BigQuery Omni and federated queries cannot reach an on-prem Hadoop lake, so "query in place across both" is not technically available. Push-up extract is the only sound daily pattern.

Serverless economics

  • Dataflow, BQ, STS, Composer are all managed: cost scales with GB processed, not idle clusters. A daily job that runs 2 hours costs 2 hours.
  • On-demand analytics burst on BQ autoscaling without capacity planning.

One codebase

  • The current "existing code build for on-prem vs GCP" fork doubles every change and lets logic drift. Beam runs identical code batch and streaming — Phase 3 becomes a deployment change, not a rewrite.

Privacy by design

  • Hashing & tokenization run inside Cloud DLP the moment data lands — never by hand, never in a bespoke library — with k-anonymity in gold and a VPC-SC perimeter around everything. Physical egress carries aggregated data only, to a named recipient (the client); everything else — Eureka, vendors — is zero-copy through Analytics Hub, so there is no file to lose. Anonymization is enforced structurally, not by policy documents.
Alternative consideredVerdictWhy rejected
Query on-prem lake federated from BigQueryNot possibleBQ federation covers Cloud SQL/Spanner/GCS; BQ Omni covers AWS/Azure only — no on-prem connector exists.
Pull location data down to on-prem for the matchRejectedMoves the largest, most sensitive dataset the wrong way; duplicates governance; violates data-gravity and privacy posture.
Lift the Hadoop cluster into Dataproc (always-on)RejectedRecreates cluster ops and idle cost in the cloud. Acceptable only as a bridge via Dataproc Serverless while Spark code migrates to Beam.
Keep dual codebases, sync outputs nightlyRejectedLogic drift between environments is already a known pain; doubles test surface and slows every change.
Tokenize/mask on the on-prem edge before transferSupersededWorks, but means maintaining a crypto library on-prem outside GCP's governed tooling. Centralizing on Cloud DLP in GCP is simpler to operate and audit — offset by tighter GCS bucket controls (component 3).
Raw extract → GCS landing → Cloud DLP → Dataflow → BigQuery✓ ChosenMinimal data movement, all-Google stack, masking via a prebuilt managed service, one codebase, structural privacy, direct streaming upgrade path.

If the existing code is Spark: Dataproc or Dataflow?

The current on-prem pipeline is written in Spark. That doesn't change the target — it changes the path to it. runs the existing Spark jobs in GCP with no rewrite, so it's the right vehicle to migrate fast in Phase 1. stays the long-run target because it's the only one of the two that shares one codebase across today's daily batch and Phase 3 streaming — which is the whole point of retiring the on-prem/GCP code fork. Recommendation: lift-and-shift onto Dataproc Serverless first, then port the join/aggregate logic to Beam during Phase 1–2, so Phase 3 is a deployment change, not a second migration.

DimensionDataproc Serverless (Spark, as-is)Dataflow (Beam, ported)
Existing Spark/PySpark runs unchangedRequires porting transforms to Beam
Days — lift and shiftWeeks — rewrite + test
Spark Structured Streaming is a separate code path in practiceSame Beam pipeline runs both, by design
None (serverless) but session-based pricing has a startup/idle tailNone — scales to zero between DAG runs
Good, via connectorsTightest — built by the same team as BQ
No — still a second runtime/language trackYes — this is what retires the code fork
— get live in GCP fast — where components 5 and 14 end up
04 · Run surfaces

Where production code runs vs where ad-hoc analysis happens

A hard boundary between the two keeps daily deliverables reliable and lets analysts move fast without breaking them.

Production — automated, no humans in the loop

Dataflow + BigQuery SQL, orchestrated by Composer

  1. → Cloud Build CI (tests, lint) → artifacts to Artifact Registry as Dataflow and versioned SQL.
  2. are the only thing allowed to launch prod jobs — on schedule or on GCS-arrival sensor.
  3. Jobs run as dedicated service accounts with least-privilege IAM; humans have no write access to prod datasets.
  4. Separate ; promotion only via CI. Failures page the on-call via Cloud Monitoring.
  5. Heavy transforms run in ; set-based aggregation runs as inside the DAG (cheapest engine for each step).
Ad-hoc — interactive, on demand

BigQuery Studio on the curated & gold zones

  1. Analysts use : SQL workspaces + Python notebooks (Colab Enterprise) directly on BQ — no data extracts.
  2. Access via authorized views over curated/gold only; policy tags block raw token columns. Never on the raw zone.
  3. On-demand slots with max-bytes-billed guardrails and per-user custom quotas; heavy recurring analyses get promoted into the prod DAG.
  4. Cross-dataset match on demand = plain SQL join on the shared token in BQ; if a field isn't in the daily extract, request a parameterized one-off extract job — the standing feed is never widened ad hoc.
  5. Results shared via Analytics Hub or a governed export, not CSV email.
05 · Data privacy

How privacy is maintained

Identifiers

  • MDNs are hashed/tokenized by immediately on landing in GCP — before any durable, human-accessible zone is written. The GCS bucket that briefly holds raw data is SA-only IAM, CMEK-encrypted, VPC-SC-perimetered, and auto-deletes within ~48 hours.
  • The same DLP template/key tokenizes location-side MDNs, so joins work on tokens; no curated or gold table in BQ ever holds a clear MDN.
  • Eligibility/opt-out filtering happens (step 1) — ineligible records never leave the source at all.

Aggregation & outputs

  • Gold zone enforces (suppress groups below k) — matching the "24 hr aggregate + anonymize" steps in the original design.
  • External deliverables can add for formal guarantees.
  • The client (component 11) always gets gold-zone 24h aggregate only, physically delivered — no exception. Eureka and vendors (components 12, 13) consume via Analytics Hub grants that default to gold as well; a curated-level (tokenized, row-level) grant is possible but requires a documented privacy review and policy-tag entitlement first — it is never the default.

Platform controls

  • perimeter prevents data exfiltration even with leaked credentials; CMEK everywhere.
  • Column-level + row-level security; Dataplex lineage shows exactly where every field flows.
  • All access logged to Cloud Audit Logs; DLP scans curated zone for accidental PII leakage.
06 · Maintenance

How this is maintained day to day

Daily operations

  • Composer is the single pane: DAG status, SLA misses, retries. A missed on-prem drop alerts before consumers notice.
  • Dataplex data-quality rules gate promotion from raw → curated; bad batches quarantine to a dead-letter dataset with automatic reprocessing on fix.
  • Backfills are a Composer parameterized run over the GCS raw zone — no on-prem re-extract needed within retention.

Change management

  • Everything is code: pipelines, DAGs, SQL, IAM, and infrastructure (Terraform). PR review + CI is the only path to prod.
  • Schema contract between the on-prem edge job and the GCS bucket is versioned; additive changes only, enforced in CI.
  • Monthly: review BQ slot utilization & on-demand spend, storage lifecycle hit-rates, DQ trend, key rotation.

Because it's serverless

  • No cluster patching, no capacity planning, no idle VMs — Google maintains Dataflow, BQ, STS, Pub/Sub runtimes.
  • The maintenance surface is your code + configuration, which is exactly what the team can own with 1–2 data engineers on rotation.
07 · Adoption

How and why this architecture should be used

How — phased

  • stand up VPC-SC perimeter + KMS, build the filtering-only edge job + STS transfer, configure the GCS bucket and Cloud DLP de-identification templates, land join/aggregate on Dataproc Serverless (or Beam directly), daily match in BQ, Client Delivery live and Analytics Hub listings published for Eureka and any GCP-resident vendors, Composer DAG orchestrating end to end.
  • retire on-prem duplicate ETL for matched products; move POI + demographics joins fully into the reference layer; Analytics Hub replaces bucket drops.
  • streaming browsing ingestion (Pub/Sub/Datastream), historical backfill, dual-run validation, on-prem becomes source-only.

Why — for the business

  • Daily location × web matches become a reliable product with SLAs, not a best-effort script.
  • On-demand cross-dataset questions answered in minutes in BQ instead of multi-day cross-environment engineering.
  • Partner-ready: Analytics Hub gives governed, revocable sharing for enterprise customers (e.g., the Omni product line); S3/SFTP delivery meets hedge funds where their existing ingestion already lives.

Rules of the road

  • New data products start as ad-hoc analyses in BQ Studio; once run twice a week, they get promoted into a Composer DAG.
  • No pipeline outside Composer; no dataset without an owner, DQ rule, and policy tags; no clear identifiers, ever.
  • Widening the on-prem extract requires a privacy review — default answer is a one-off parameterized extract.