Cost Model & Estimates (Total Cost to Operate the Module)

Purpose: A single, auditable view of what it costs Kobi to run the Digital Ads module — LLM inference + Vertex Agent Engine + core GCP infra + data warehouse + (optional) first-party relay + one-time build. This complements the detailed LLM cost catalog (kept as the source for token-level numbers) by consolidating every cost layer into per-tenant and portfolio totals.

Audience: Parent-project / VC finance and engineering. Commercial figures (pricing, media take-rate, revenue) are owned at the parent/VC level — this doc is the cost side only, so those numbers can be slotted against it.

Confidence: Planning bands. Unit prices verified June 2026 against the sources in §1; re-verify before any commitment — cloud and model prices drift, and several Gemini/Agent-Engine SKUs are new in 2026.

Related: Agentic orchestration — LLM cost catalog · GCP topology · First-party tag relay — cost · Execution gameplan

---

0. Scope — what is and isn't counted

Tenant profiles (from media-planning) and portfolio sizes (Pilot 5 / Growth 50 / Scale 200) match the existing docs so numbers reconcile.

---

1. Unit prices (verified — source table)

Vertex global standard (non-batch) rates; GCP Tier-1 region (e.g. europe-west1). First-tier free allowances noted.

---

2. Recurring cost by layer

2.1 LLM inference (the dominant variable cost)

From the per-task catalog. Expected (standard, no cache), per tenant / month:

2.2 Vertex Agent Engine runtime (agent compute, separate from tokens)

Agent Engine bills the container wall-time of agent invocations (model tokens billed separately in §2.1). Idle is not billed; first 50 vCPU-h + 100 GiB-h/month are free (absorbs the pilot almost entirely).

Assumptions: ~1 vCPU + 2 GiB per invocation; avg ~15 s wall-time/invocation; invocation counts from the task catalog; ~3 session events/invocation.

Free tier covers ~8 vCPU-h before billing — i.e. the first 1–2 tenants are effectively free; the per-tenant numbers above apply at steady-state scale.

2.3 Cloud Run (orchestrator control plane, connectors, BFFs, Cost Guard, jobs)

Two parts: fixed warm services (see §4) and per-tenant request/compute (connector mutations, polling, reporting). Requests are negligible at $0.40/M; compute is short bursts.

2.4 Data warehouse (BigQuery: Google Ads export + telemetry)

Per tenant: Google Ads export storage is tiny (tens of MB/mo for an SMB); reporting/optimization joins scan a few GB/mo; QC/Cost-Guard telemetry adds rows. Partitioning by tenant_id + clustering keeps scans small (the docs already specify this).

Risk lever: un-partitioned queries can 10–100× this. Enforce partition/cluster + SELECT only needed columns (already in the playbook).

2.5 Other GCP (Pub/Sub, Secret Manager, GCS, Logging, egress) — per tenant

2.6 First-party relay (Phase 2+, optional SKU)

From relay cost: ~$1–3/tenant (low traffic) to $6–12 (high traffic); ~$80–150/mo total at 50 tenants (hybrid Cloudflare + Cloud Run). Deferred / not in base run-cost below unless the relay SKU is sold.

2.7 Platform API costs

$0. Google Ads, Meta Marketing, TikTok Marketing, DV360, GA4 Data/Admin APIs are free to call — the constraint is rate limits and approval tiers, not metered fees (see platform access).

---

3. Per-tenant total cost of ownership (blended, excl. relay & media)

Sum of §2.1 (expected) + §2.2 + §2.3 + §2.4 + §2.5:

Non-LLM infra is ~10–15% of per-tenant cost; LLM dominates. Optimization frequency and tool-loop depth are the real levers (§5). Add +$1–12/tenant if the relay SKU is enabled.

---

4. Fixed baseline infra (independent of tenant count)

Costs incurred even at zero/low tenants — mostly warm prod services + non-prod environments.

Vertex Agent Engine + Cloud Run + BigQuery free tiers absorb most pilot-scale usage, so at 1–5 tenants the bill is dominated by this fixed baseline, not per-tenant cost.

4.1 Cutting the warm-service baseline

Warm (min-instance) services are the largest fixed cost, so they're worth optimizing. Conclusion: cut warm cost aggressively, but stay on Cloud Run — do not move the control plane to VMs.

Why not VMs (the serverless control plane wins here):

• The control plane is mostly async/event-driven — orchestrator, connectors, Cost Guard, and jobs are Pub/Sub-triggered, so they don't need to be warm at all; they should scale to zero. Only the human-dashboard BFF is latency-sensitive enough to keep warm.
• "Scale resources by client amount" is already what Cloud Run does — per-request, concurrency-based autoscaling with per-tenant isolation. A hand-resized VM is worse at this: noisy-neighbor across tenants, manual vertical scaling (downtime), and no scale-to-zero.
• A VM saves only ~$50–150/mo but adds OS patching, container orchestration, health checks, capacity planning — ops/eng time that costs far more than the saving and breaks the serverless-first principle (system overview). Startup credits (§9.1) zero this line in Year 1 anyway.

The real levers (all within Cloud Run) — together ~−60–70% on the warm line:

Where a VM does pay: long-running batch (e.g. heavy continuous optimization sweeps) on Spot VMs (~−60–91%). But Cloud Run Jobs already scale to zero, so a Spot VM only wins if the batch runs continuously for hours — not the case at pilot/growth scale. Revisit only if a sustained batch workload emerges.

---

5. Portfolio totals (all-in monthly, expected, excl. relay & media)

Variable = Σ per-tenant (§3); plus fixed baseline (§4). Mix mirrors the existing docs.

Fixed column reflects the trimmed warm baseline from §4.1 (dashboard BFF warm, rest scale-to-zero); it grows modestly with logging/registry as tenants scale.

Blended all-in per tenant (incl. amortized fixed): Pilot ~$48 (fixed-heavy), Growth ~$26, Scale ~$22 (no cache) / ~$18 (cached).

Add relay if sold: +$80–150/mo at Growth, +$350–650/mo at Scale. Reference point: at Scale, total infra+LLM ≈ $4–5K/mo for 200 clients — a rounding error against the media budgets being managed (see §7).

---

6. One-time build cost (engineer-weeks)

Derived from the roadmap workstreams (summed effort, not calendar). Expressed in engineer-weeks so the parent/VC can apply their own loaded rate.

Calendar: ~18–26 weeks with 2–4 engineers (matches roadmap). Illustrative cost = engineer-weeks × your loaded weekly rate (rate is parent/VC-owned). The MVP cut (gameplan §4) defers ~15–20 of these weeks (Cost-Guard/QC-telemetry/model-promotion/relay/DV360) to protect the pilot date.

Build-phase cloud cost is negligible (free tiers + dev min-instances 0): plan ~$100–300/mo during build for dev/staging + test inference.

---

7. Media float / working capital (not opex)

The single largest cash item is not in the tables above because it is not Kobi's cost — it is client media budget Kobi fronts and recovers under the agency-billing model:

• Kobi pays platforms (often on extended credit) and invoices clients monthly → Kobi carries ~1 month of every client's media spend as a receivable.
• At Growth (50 clients × e.g. ₺50–150K/mo media), the float can be ₺millions — orders of magnitude larger than the ~$1.2K/mo infra cost.
• This is a balance-sheet/financing question, not an operating cost, but it must be planned. Engineering lock (ADR 0004): every tenant has a per-tenant spend limit (credit_sub_limit + platform caps). If clients prepay, the limit tracks prepaid balance from the parent billing module's internal API; if payment works differently, finance / parent billing must define the limit source before prod.
• Flagged in gameplan B3.
• Tax on media spend (VAT/KDV + foreign-platform digital-services/withholding tax) further grosses up the invoiced amount and the float; tax treatment is parent/VC finance-owned — see vision & scope — billing. Not in the infra cost tables.

---

8. Sensitivity & levers

Three-point band (per tenant, Standard, incl. infra): Low ~$22 · Expected ~$28 · High ~$60. Design budgets to the High band, then replace assumptions with real run_id token logs from the pilot (Cost Guard ledger).

Optimize cost per accepted output, not $/1M tokens. When tuning model tiers, the objective is the lowest cost per QC-passed, human-accepted task — a cheaper model that fails QC triggers correction loops/retries/escalations that can cost more end-to-end. Start cheap and escalate on QC failure, demote on sustained success (model promotion/demotion); never demote safety/compliance-critical tasks on price (Special Ad Category, policy QC, health/education stay pinned to the higher tier).

---

9. Commitment & credit savings (GCP)

Three distinct mechanisms — only two are worth taking at this scale. Verify all rates/eligibility before committing.

9.1 Optional — Google for Startups Cloud Program (credits)

Not assumed in run-cost tables below. Leadership decides whether to apply; confirm with VC/board before pursuing.

Because this module is part of a VC/equity-backed project, it may qualify for Google's startup credits — which would dwarf run cost if granted:

• Covers: Gemini models + GCP services — Vertex AI, Agent Engine, BigQuery, Cloud Run, Pub/Sub, etc. (i.e. essentially the entire model in §3/§5).
• Excludes: third-party models (Claude Sonnet/Opus escalation, Llama) — billed directly — and Marketplace. Escalation is ~2% of LLM spend, so coverage is ~98%+ of the bill.
• Effect: run cost is ~$4K/yr (pilot) → ~$17K/yr (growth) → ~$55K/yr (scale) — all far under the $250K Year-1 cap. So Year 1 GCP+Gemini cost is effectively ~$0; only the 2% third-party escalation (tens of $/mo) is billed. Year 2 covers 20%.
• Caveat: credits are runway, not a permanent discount — they expire at end of term. Use them to absorb the build + early-scale window, and budget steady-state to the §9.2/§8 numbers for after credits lapse.
• Action: apply via the Google for Startups portal (no traditional grant application); confirm AI-tier eligibility with the account team while opening the Meta/DV360 relationships (gameplan PF track).

9.2 Committed Use Discounts (CUDs) — steady-state, after credits

Spend-based Compute Flexible CUD: commit a minimum hourly spend; overage bills on-demand.

• Net effect: applies only to the Cloud Run slice ($150–340/mo at scale), so absolute saving is **$40–90/mo at Scale** — real but small, since compute isn't the cost driver.
• Low risk if you size the commitment to the always-on baseline only (not per-tenant burst).

9.3 Where commitment does NOT pay at this scale (avoid the trap)

9.4 Stacked effect (illustrative)

Order of magnitude of the levers: startup credits ≫ context caching > batch ≈ Cloud Run CUD ≫ BigQuery/PT commitments (negative here). Keep the design Gemini-first (already the policy) to maximize credit coverage, since third-party models are the only uncovered slice.

---

10. Bottom line

• Per active client: ~$8–42/mo (profile-dependent, expected) all-in infra+LLM; ~$19–28 blended at scale.
• Portfolio: ~$240/mo (pilot) → ~$1.1–1.3K/mo (50) → ~$3.7–4.5K/mo (200), excluding optional relay.
• Fixed baseline ~$220/mo (trimmed warm services, §4.1) dominates until ~12–18 tenants.
• Build — assumed go-live DDL (core, solo sprint): ~13 weeks calendar; G+M+T ~W9. Full-module accounting: ~50 engineer-weeks core (~67–69 with DV360 + relay) — capacity planning only, not MVP calendar.
• The dominant cash item is media float (working capital), not infra — plan it separately.
• All platform ad APIs are free; cost risk is concentrated in LLM optimization frequency — directly governed by Cost Guard + model routing already in the design.
• GCP commitment/credits (§9): the Google for Startups Cloud Program (up to $350K / 2 yrs) effectively zeros the GCP+Gemini bill in Year 1 (only ~2% third-party escalation billed). Cloud Run CUDs add ~17–46% on the small compute slice afterward. Do not commit BigQuery slots or Vertex Provisioned Throughput at this scale — on-demand is cheaper.

---

Related documents

• Agentic orchestration — LLM cost catalog & Cost Guard
• GCP deployment topology — cost controls
• First-party tag relay — cost estimation
• Execution gameplan & VC-readiness
• Roadmap & timelines