Chris Collins

Tools · cloud

GCP architecture builder

Draw a Google Cloud architecture on an interactive diagram — a project, its region and VPC network, and 37 mainstream services, including a big-data platform (warehouse, batch and stream processing) and a search and caching service tier — configure each service, see a rough monthly cost, and download Terraform that passes terraform validate.

Added

How to use it

An architecture-diagram editor for Google Cloud that knows what the boxes mean. Drag services onto the canvas, drop VMs and databases into a VPC network, and connect them: each connection is checked (Pub/Sub can push to Cloud Run; Cloud Storage can’t write to Firestore by itself) and becomes code — a least-privilege IAM binding on the resource it touches, a firewall rule, a push subscription with a dead-letter topic, an Eventarc trigger, a load-balancer backend, a DNS record. Alongside the diagram you get live Terraform for the hashicorp/google provider, a monthly cost estimate with editable usage assumptions, and a list of checks (a public bucket, Cloud SQL without high availability in production, a Cloud Run service that anyone can call by mistake, a push subscription without a dead-letter topic, a port open to the internet). Nothing is sent anywhere: the builder never talks to Google Cloud, and your designs stay in this browser. It is the Google Cloud sibling of the AWS architecture builder.

How to use it

Start from an example (Examples…): a static website, a serverless API, a three-tier web app, an event-driven pipeline, a GKE Autopilot platform, scheduled jobs, microservices on Cloud Run, a low-cost hobby project or an internal app behind IAP — and, under Data & analytics, a streaming data pipeline, a big data platform, real-time analytics, a search-backed product catalog and a lakehouse. Each shows its rough monthly cost in the list; once loaded, the Design panel explains what the example shows and the usage behind its cost. Or choose Design ▾ → New empty design.

Add services by dragging them from the palette on the left onto the diagram, or tap one to drop it in the middle of the view. On a phone, + Add opens the palette as a sheet. Services are colour-coded by category with simple generic glyphs (they are not Google’s product icons).

The hierarchy is drawn as nested frames: the project holds everything you deploy; the region frame holds regional resources, while global ones — the external Application Load Balancer, Cloud CDN, Cloud Armor, Cloud DNS, IAP and Identity Platform — sit outside it. A VPC network is a container (VPC networks are global; their subnets are regional) with two bands: the subnet, where Compute Engine VMs, managed instance groups, GKE clusters, internal load balancers and Dataflow workers live, and private services access, the peered range where Cloud SQL, AlloyDB and Memorystore get private IPs. Columns are zones: instance groups, regional GKE clusters and HA databases spread across them; a single VM uses the zone it sits in. Drop a Cloud Run service, job or function into the subnet to give it Direct VPC egress (or a Serverless VPC Access connector) so it can reach private databases. Cloud NAT (with its Cloud Router) and Private Google Access are settings of the VPC network. Drag a VPC by its border to move it with everything in it, and by its corner to resize it.

Connect two services by dragging from the arrow handle of the selected service (or any of the four ports that appear on hover) to another service. The status line tells you, before you let go, whether the connection is allowed and what it will mean; an invalid one explains why and suggests what to do instead. Connections have kinds — routes to, invokes, reads/writes, reads, writes, triggers, publishes, attached, encrypt/decrypt, monitors — and some let you choose (a service can read, write or read and write a bucket). Select a connection to change its kind and its details: an API Gateway route, a load-balancer path rule, a DNS record name, a Cloud Storage notification prefix. On a phone, select a service and use Connect, then tap the target — or turn on ⤳ Connect mode.

Configure a service by selecting it: the inspector shows the settings that matter (machine types, CPU and memory, minimum and maximum instances, ingress, HA, backups, dead-letter topics, schedules…) with defaults and a short explanation, the firewall rules and IAM bindings derived from its connections, its connections, and its usage assumptions and monthly cost. Hover over anything for a summary.

Move around: drag the background to pan, use the wheel or pinch to zoom (a trackpad’s two-finger scroll pans), Shift-drag to select several services, ⊞ Layout to arrange everything left to right by request flow and ⤢ Fit to zoom to fit. ▶ Request path animates a request from the Users node through the architecture (with reduced motion it simply highlights the path). $ shows each service’s monthly cost on the diagram and Aa toggles the connection labels. Drag the diagram’s bottom edge to make it taller (double-click the edge to go back to the default, which follows the height of the window); the height is remembered.

Full screen: ⛶ Full screen at the top right (or F) gives the whole tool the screen — the diagram, the Terraform, the cost and the checks — using the browser’s full-screen mode, or filling the window where the browser can’t (an iPhone). The diagram takes all the room left and refits to it; ◧ Services and Inspector ◨ (or [ and ]) hide and show the side panels, so the diagram can run edge to edge, and the choice is remembered. Esc or ✕ Exit leaves, back where you were on the page.

Keyboard: Delete removes the selection, ⌘Z / ⇧⌘Z undo and redo, ⌘D duplicates, ⌘A selects all, arrow keys nudge (Shift for bigger steps), C connect mode, L layout, 0 zoom to fit, 1 actual size, F full screen, [ / ] side panels (in full screen), P request path, G snap to grid, +/− zoom, Esc cancels (and leaves full screen). ? lists them.

The Terraform

The Terraform tab shows the generated configuration, highlighted, file by file: versions.tf (Terraform ≥ 1.9, hashicorp/google and google-beta ~> 8.7), providers.tf (project, region and default labels), variables.tf, main.tf (every API the design needs, enabled with google_project_service), network.tf, iam.tf, compute.tf, data.tf, messaging.tf, analytics.tf, search.tf, edge.tf, security.tf, monitoring.tf, outputs.tf, a terraform.tfvars.example, a README with the resource list, cost and checks, OpenAPI and Workflows YAML where needed, and stub source for every Cloud Run function, PySpark stubs and Airflow DAGs. Download .zip gives you the whole configuration. Show code in the inspector (or Jump to service) highlights the lines a service produced, in every file it appears.

The code uses the current, idiomatic resources — google_cloud_run_v2_service, google_cloudfunctions2_function, google_sql_database_instance, google_pubsub_subscription with push, BigQuery and Cloud Storage configs, google_eventarc_trigger, the global external Application Load Balancer as a global address, managed certificate, HTTPS proxy, URL map, backend services (serverless network endpoint groups for Cloud Run and functions, backend buckets for Cloud Storage) and an HTTP-to-HTTPS redirect. Every workload runs as its own service account, and each connection becomes the narrowest role on the narrowest resource Google Cloud allows: a Cloud Run service publishing to a topic gets roles/pubsub.publisher on that topic; a service reading a bucket gets roles/storage.objectViewer on that bucket; Pub/Sub push, Eventarc, Cloud Scheduler, Cloud Tasks, Workflows and API Gateway get roles/run.invoker on exactly the service they call. Firewall rules target the service accounts of VMs and instance groups and allow only the health-check, proxy-only, IAP or source-service-account ranges the connections need. Services get environment variables naming what they are connected to. The Dev/Prod switch sets deletion protection (Cloud SQL, Cloud Run, GKE, Spanner, Bigtable, Firestore, BigQuery), whether buckets and datasets are emptied on destroy, backup retention, and makes the checks stricter.

Every example, and a design that uses every service type at once, is checked by running terraform init -backend=false, terraform validate and terraform fmt -check with Terraform 1.16.6, provider 8.7.0 and elastic/ec 0.13.1 — no credentials, no Elastic API key and no calls to Google Cloud or Elastic. Validation proves the configuration is well-formed against the provider’s schema, not that apply will succeed in your project: read it, run terraform plan, and only then apply.

The data platform and the service tier

The Data & analytics, Integration and Search & caching groups of the palette cover a whole data platform:

  • Warehouse — BigQuery. A dataset with a table partitioned by day (on ingestion time or a column) and clustered by up to four columns, optionally requiring a partition filter. Pricing is on-demand ($6.25 per TiB scanned) or an Editions slot reservation (Standard, Enterprise, Enterprise Plus: baseline slots plus autoscaling, assigned to the project). Connect the dataset to a bucket for a BigLake external table (Parquet, Avro, ORC, JSON or CSV with Hive-style partitions) read through a BigQuery connection whose own service account holds the bucket access; add SQL for a scheduled query run as the dataset’s own service account. Pub/Sub can write straight into it with a BigQuery subscription.

  • Batch — Dataproc and Dataflow. A Dataproc cluster (the service is now called Managed Service for Apache Spark) has a master, primary workers and Spot secondary workers, an autoscaling policy and idle deletion; it runs as its own service account with roles/dataproc.worker, and a firewall rule lets its nodes talk to each other. Dataproc Serverless runs a PySpark or Spark SQL batch with no cluster: the builder uploads a stub script to a code bucket and passes the connected buckets and tables as arguments. A Dataflow job in batch mode reads a bucket or a table (Google’s Cloud Storage Text → BigQuery template, or your own Flex Template). Batch work is started by Cloud Composer (Airflow 2 or 3 on Composer 3 — the generated DAG gets a task per connection: DataprocCreateBatchOperator, DataprocSubmitJobOperator, DataflowStartFlexTemplateOperator, BigQueryInsertJobOperator, CloudRunExecuteJobOperator), by Cloud Scheduler (calling the Dataproc batches or Dataflow launch API) or by Workflows. The launcher gets roles/dataproc.editor or roles/dataflow.developer and roles/iam.serviceAccountUser on the job’s own service account only.

  • Streams — Pub/Sub, Managed Kafka and Dataflow. Pub/Sub or a Managed Service for Apache Kafka cluster (vCPUs, memory, a topic) feed a streaming Dataflow job: Google’s templates for Pub/Sub or Kafka → BigQuery or Cloud Storage and Pub/Sub → Elasticsearch, or your own Flex Template with window and allowed-lateness settings when it writes to several places (BigQuery, Cloud Storage, Bigtable for low-latency serving, Elastic). The Dataflow service account gets roles/pubsub.subscriber on its subscription, roles/managedkafka.client for Kafka and the data roles on exactly the sinks it writes.

  • Change data capture — Datastream. Cloud SQL (PostgreSQL or MySQL) or AlloyDB → Datastream → BigQuery or Cloud Storage. It reaches a private database through a Private Service Connect interface in the VPC (VPC peering isn’t transitive, so it couldn’t reach Cloud SQL’s private IP), turns on logical decoding on Cloud SQL, reads the database password from Secret Manager, and is created stopped: the stack outputs the SQL that creates the user, publication and replication slot.

  • Service tier — search and caching. Google Cloud has no managed OpenSearch, so the builder offers the realistic options. Vertex AI Search (Google’s managed search, now part of Agent Search) is a data store and a search app (google_discovery_engine_*), Standard or Enterprise edition, with imports from Cloud Storage or BigQuery; serverless, billed per 1,000 queries. Elastic Cloud runs Elasticsearch and Kibana in the same Google Cloud region, billed by Elastic or through Google Cloud Marketplace, generated with Elastic’s official elastic/ec Terraform provider (ec_deployment): reach it privately over Private Service Connect (an endpoint and a private DNS zone in your VPC, plus Elastic’s traffic filter), or from fixed addresses through an IP filter; callers read the password from Secret Manager. Choose it when you need Elasticsearch’s query DSL, aggregations or the Elastic stack. The third option, self-managed OpenSearch or Elasticsearch on GKE (the OpenSearch Helm chart or operator, or Elastic’s ECK operator), gives full control and no licence fee in exchange for running the cluster yourself; draw a GKE cluster for it — the workload isn’t generated. Memorystore covers caching: a Redis instance (Basic, or Standard with an HA replica), Redis Cluster or Valkey, sharded with replicas.

Run terraform for designs with Elastic Cloud with EC_API_KEY set to an Elastic Cloud API key; validation needs no key.

Cost estimates

The Cost tab totals a rough monthly cost per service with a bar chart, the biggest cost drivers, and the charges that are easy to overlook — Cloud NAT (per VM-hour plus $0.045 per GiB and its external IP), load-balancer forwarding rules ($0.025 an hour for the first five in a project) and internal load-balancer proxies, internet egress, idle minimum instances on Cloud Run, and high availability, which doubles Cloud SQL’s price — and, for data platforms, a Composer environment that bills around the clock whether or not a DAG runs, streaming Dataflow workers that run all month, queries that scan a whole unpartitioned BigQuery table, baseline slots, and cache replicas (one replica per shard doubles Memorystore’s nodes; the Standard tier costs about 30% more than Basic). Expand a row to edit its usage assumptions (requests, request time, GB stored or processed, reads and writes, average VMs, nodes or pod resources…) and to see each line as quantity × rate.

Prices are public list prices for us-central1 (Premium network tier, no committed-use or sustained-use discounts), read on 14 and 15 October 2026 from Google Cloud’s public pricing pages without an account; every row links to its page, e.g. https://cloud.google.com/run/pricing. The data platform uses: BigQuery $6.25 per TiB scanned on demand, $0.023 and $0.016 per GiB-month of active and long-term storage, and $0.04, $0.06 and $0.10 per slot-hour for the Standard, Enterprise and Enterprise Plus editions; Dataproc’s $0.01 per vCPU-hour on top of the Compute Engine VMs (Spot prices for secondary workers) and $0.06 per DCU-hour for Dataproc Serverless; Dataflow $0.069 per streaming and $0.056 per batch vCPU-hour, $0.003557 per GB-hour of memory, $0.018 per GB through Streaming Engine and $0.011 per GB shuffled in batch; Composer 3 $0.06 per DCU-hour; Managed Kafka $0.09 per DCU-hour (1 vCPU = 0.6 DCU, 1 GiB = 0.1 DCU) plus storage and $0.01 per GiB replicated between zones; Datastream $2 per GiB of change data (less above 2,500 GiB) and $0.40 per GiB of backfill above 500 GiB a month; Vertex AI Search $1.50 or $4 per 1,000 queries and $5 per GiB-month of index above 10 GiB; Memorystore Redis Cluster and Valkey per node-hour. Elastic Cloud is Elastic’s price, not Google’s: the “as low as” monthly price per subscription tier (Standard $99, Gold $114, Platinum $131, Enterprise $184) from Elastic’s pricing page, for its reference production deployment (120 GB of storage over two zones), billed through Google Cloud Marketplace if your Elastic organisation subscribes there — enter a size multiple from Elastic’s calculator. The other regions — us-east1, us-west1, europe-west1, europe-west2, asia-northeast1 and australia-southeast1 — multiply them by a ratio measured from the same pages per family (Compute Engine, Cloud SQL, Cloud Run, Cloud Storage, GKE Autopilot, Memorystore, internet egress); other services use the us-central1 price. Apply free-tier allowances subtracts the free tier, shared across the design: 2 million Cloud Run requests with 180,000 vCPU-seconds and 360,000 GiB-seconds, Firestore’s 50,000 reads and 20,000 writes a day, 1 TiB of BigQuery queries and 10 GiB of storage, 10 GiB of Pub/Sub, 5 GB of Cloud Storage and one e2-micro VM in the US regions, three Cloud Scheduler jobs, the GKE cluster-fee credit and more. The first 50 GiB of logs a month are always free, and Identity Platform’s first 50,000 monthly users are free whichever way the switch is set. The $300 trial credit is not modelled. Treat the total as a rough estimate and check it with the Google Cloud Pricing Calculator.

Checks and designs

The Checks tab lists errors (things that won’t deploy or are unsafe), warnings and notes, with Fix buttons where the fix is a setting, plus every firewall rule and IAM binding the design produces. Among them: buckets readable by allUsers (fine only for a website behind the load balancer), Cloud SQL with a public IP or authorized networks, no HA or backups in production, Cloud Run allowing unauthenticated calls when every caller authenticates — or not allowing them behind a load balancer that has no IAP, where requests arrive unauthenticated — a run.app URL that bypasses the load balancer, push subscriptions without a dead-letter topic, the default compute service account, ports open to 0.0.0.0/0 other than 80 and 443, single-zone resources in production, services that can’t reach a private database because they are outside the VPC, and a note listing data stores without customer-managed encryption keys in production. For data platforms: large unpartitioned BigQuery tables, datasets readable by allUsers or allAuthenticatedUsers, Dataproc clusters with neither autoscaling nor idle deletion, Composer in production without high resilience, streams without a dead-letter topic, search exposed publicly (an open or empty-filter Elastic endpoint, a public Vertex AI Search widget, users querying search directly), Kafka memory outside 1–8 GiB per vCPU and Dataflow jobs reading Kafka from outside its VPC. Badges on the diagram show which service has a problem.

Designs autosave in this browser (localStorage) as you work; keep several with Design ▾ (new, duplicate, rename, delete), and move them between machines with Export JSON / Import JSON. Export diagram as SVG/PNG saves a light-theme picture of the diagram. Share link packs the current design into the link — designs hold settings and names only, never secrets.

Limits

  • About 37 mainstream services, each with the settings that matter most — not every option. One region per design; no Shared VPC, VPC peering, multiple projects, App Engine, Apigee, Cloud Build pipelines, Dataplex, Dataform, Looker or Vertex AI training.

  • Data jobs are scaffolding: your own Dataflow pipelines are referenced as a Flex Template you build (*_template variables), Spark scripts and DAGs are stubs to replace, Google’s template parameters and table schemas need adjusting to your data, and Vertex AI Search data is imported after applying. Datastream is created stopped until the source database is prepared. Elastic Cloud’s Private Service Connect service attachment for your region comes from Elastic’s documentation (a variable). Self-managed OpenSearch on GKE is described, not generated.

  • Container services start from Google’s public sample images: build and push your own image and set the *_image variables. Functions are generated with Node.js or Python stubs. GKE workloads are deployed with kubectl or Helm, not here (Workload Identity is wired for the Kubernetes service account app).

  • Secrets are created without a value (add one with gcloud secrets versions add), so nothing secret ever lands in Terraform state. Cloud KMS key rings can’t be deleted, so re-creating a design needs a new name.

  • Cloud Armor policies protect backend services, not backend buckets (those need an edge policy, not generated). IAP is attached through the external load balancer.

  • Costs ignore committed-use and sustained-use discounts, volume tiers beyond the first (except Datastream’s), Spot VMs other than Dataproc secondary workers (Spot prices change monthly), taxes and support, and assume 730 hours a month. Cloud Run is billed for each request’s own duration (one request per instance at a time), which overestimates busy services; Cloud Run jobs aren’t given a free tier. Regional prices are ratios, not per-region tables.

Linking to an example

?example=<preset> opens an example as a new design in your browser (your other designs are kept); add a tab after #: diagram (the default), code, cost or checks. Share link writes your own design into a packed ?s= parameter.

Parameter Meaning Example

example

One of the presets below

example=three-tier

s

A packed design (made by Share link)

—

Preset What it is

static-site

A public website bucket behind a global external Application LB with Cloud CDN, a managed certificate and Cloud DNS

serverless-api

API Gateway validating Identity Platform tokens, in front of a Cloud Run service and a function, with Firestore and alerts

three-tier

Global LB with Cloud CDN and Cloud Armor → managed instance group → Cloud SQL HA and Memorystore, in a VPC with Cloud NAT (prod)

event-driven

Cloud Storage upload → Eventarc → Cloud Run → Pub/Sub with a dead-letter topic → Cloud Run → BigQuery

gke-platform

GKE Autopilot with private nodes, Artifact Registry, Cloud SQL HA, Memorystore, Cloud Storage and Secret Manager (prod)

data-pipeline

Devices → Pub/Sub → Dataflow template → BigQuery, with a Cloud Storage subscription archiving the raw messages

big-data-platform

Cloud Run ingest → Pub/Sub and Managed Kafka → Dataflow streaming to Bigtable, Elastic Cloud and a data lake; a Memorystore-cached search API; Composer-run Spark batches into BigQuery with BigLake (≈ $1,815 a month)

realtime-analytics

Pub/Sub → Dataflow → a partitioned, clustered BigQuery table for Looker Studio, with a scheduled daily summary (≈ $165)

search-catalog

HTTPS load balancer → Cloud Run catalog API → Vertex AI Search, Memorystore and Cloud SQL, with Datastream CDC into BigQuery (prod, ≈ $1,129)

lakehouse-batch

Cloud Scheduler → Dataproc Serverless Spark from a landing bucket to a curated Parquet lake, BigLake tables and a scheduled query in BigQuery, and an autoscaling notebook cluster (≈ $159)

scheduled-jobs

Cloud Scheduler runs a nightly Cloud Run job and an hourly workflow that calls a service and publishes a message

microservices

A load balancer routes to a frontend and an orders API on Cloud Run; billing and shipping receive order events by push

hobby-project

One public Cloud Run service scaling to zero with Firestore, a bucket and a secret — usually inside the free tier

internal-app

Staff sign in through IAP on a load balancer; a private Cloud Run service reaches Cloud SQL over Direct VPC egress (prod)

Runs entirely in your browser; nothing you type leaves this page.