Implementation Plan: Edge-to-Activation

Purpose: Week-by-week phases, milestones, and dependencies for Edge-to-Activation engagements. Used in SOW scope sections, kickoff decks, and to populate Linear milestones. Service line: Data Subservice: Activation & attribution (legacy offering bucket: activation-attribution/) Delivery model: fixed-scope (typical Phase 0 + Phase 1) / retainer (Phase 2) Last updated: 2026-04-08

At a Glance

Phase	Name	Duration	Key output	Gate
Phase 0	Signal Recovery Audit	~1 week	Edge capture live; discrepancy report; pilot scope agreed	Client sign-off on findings
Phase 1	Pilot / Attribution	~4–6 weeks	Edge → warehouse → reverse ETL/CDP on pilot paths; testing complete; validation	Client sign-off on Phase 1; agreement to Phase 2 if retainer
Phase 2	Rollout & Maintenance (optional)	Ongoing (retainer)	Full channel rollout; monitoring; runbooks; sustained fixes	Per retainer SOW

Total duration (Phase 0 + Phase 1, typical): ~5–8 weeks (often compressed when Phase 0 and Phase 1 are combined per SOW — see SOP SOW copy block).

Effort (rough): Managing Lead 16–24h · Senior Engineer / Data 80–120h · PM 12–20h (varies by traffic complexity and warehouse stack)

Prereqs Before Kickoff

SOW signed; phases in scope confirmed (Phase 0, Phase 1, Phase 2 retainer)
CDN/Edge access path agreed (Cloudflare, Fastly, or equivalent) with rights to deploy capture logic
Main domain and relevant subdomains routed through the edge network (e.g. Cloudflare orange cloud) where required — see Implementation Playbook
Data warehouse access; Edge dataset will be created in the same region/location as existing client datasets (BigQuery/Snowflake — location is immovable after creation)
Analytics / ad-platform access for reconciliation (GA4, Segment, ad accounts as applicable)
Client engineering contact for Worker/route conflicts, reverse ETL/CDP, and pixel coexistence

Phase 0 — Signal Recovery Audit

Deploy Edge capture in parallel with the existing stack; quantify signal loss and attribution gaps; align scope for Phase 1 pilot.

Duration: ~1 week (Level 1 in SOP scope table)

DRI: Delivery Lead + Senior Engineer

Week-by-week

Week	Activities	Deliverable
Week 1	Access verification (edge, warehouse, analytics); deploy Edge capture (Worker or equivalent); baseline traffic and conversions; draft discrepancy views	Edge events landing in warehouse; first-pass discrepancy narrative

Milestone: Signal recovery audit complete

Output: Discrepancy report (Edge vs client-layer); attribution gap by source/channel; documented pilot scope
Gate: Client sign-off on findings and Phase 1 scope
Dependencies: Prereqs above; no blocking Worker/route conflicts unresolved (chain or merge plan if another edge script owns routes)

Phase 1 — Pilot / Attribution

End-to-end pilot: modular Edge implementation, warehouse schema, phased testing (dev → single page → subdirectory → full pilot rollout), reverse ETL or CDP to activation tools, documentation and handoff.

Duration: ~4–6 weeks (Level 2 in SOP; calendar often maps to weeks 2–5 after Phase 0, with testing phases not compressed)

DRI: Senior Engineer + Delivery Lead

Week-by-week (pattern)

Week	Activities	Deliverable
Week 1–2	Edge Worker (or equivalent) modularized and deployed; BigQuery/Snowflake schema and ingestion; dev testing	Events reliably in warehouse; unit/integration tests green
Week 3	Single-page production test; data validation	Signed-off single-page validation
Week 4	Subdirectory or segment rollout; reconciliation vs pixels	Gap analysis aligned with expectations
Week 5–6	Full pilot scope rollout; reverse ETL/CDP wired for pilot paths; runbooks and client enablement	Phase 1 acceptance criteria met

Adjust cadence per Implementation Playbook — do not skip or compress dev → single-page → subdirectory → full rollout gates without explicit client risk acceptance.

Milestone: Phase 1 pilot complete

Output: Pilot channels covered; testing framework executed; attribution validation / discrepancy tooling usable by client; documentation and handoff
Gate: Client sign-off on Phase 1; if Phase 2 retainer is sold, commercial and scope alignment for ongoing work
Dependencies: Phase 0 sign-off (if Phase 0 ran separately); warehouse and activation tool access stable

Phase 2 — Rollout & Maintenance (retainer)

Expand beyond pilot channels; ongoing maintenance (publishers, pixels, edge changes); reporting integration; defined support and escalation.

Duration: Ongoing (typical commercial minimum 3–6 months — see SOP)

DRI: Senior Engineer + Delivery Lead (rotating with client team over time)

Cadence (typical)

Cadence	Activities	Deliverable
Weekly / biweekly	Prioritized rollout backlog; channel-by-channel verification; discrepancy monitoring	Updated runbooks; steady-state health
Monthly	Exec-ready summary of coverage, gaps, and major changes	Optional monthly review deck or doc

Milestone: Retainer operating model in place

Output: Channel rollout backlog agreed; escalation path documented; reporting hooks into client GTM/analytics rhythms
Gate: Defined SLA and commercial alignment (separate retainer SOW)

SOW Copy Block (Pasteable)

Timeline: Phase 0 ~1 week; Phase 1 ~4–6 weeks; Phase 2 ongoing retainer when purchased. Phase 0 and Phase 1 are often combined in a single statement of work — align language with the SOP SOW copy block.

Phase 0 — Signal Recovery Audit: Edge capture deployed in parallel with existing tracking; baseline and discrepancy report; attribution gap by source; alignment on pilot scope.

Phase 1 — Pilot: Edge → warehouse → reverse ETL/CDP on agreed pilot surfaces; phased testing and validation; documentation and enablement.

Phase 2 — Rollout & Maintenance: Expand to additional channels; sustained maintenance and monitoring; runbooks and support (retainer).

Client responsibilities: Timely access to edge, warehouse, analytics, and ad platforms; engineering time for route/Worker conflicts and activation tooling; review of deliverables within agreed SLA.

SOW ↔ project plan (per client)

When to use: After the SOW is signed and before Linear tickets are cut.

Canonical template: Copy sow-project-plan-template.md into knowledge/clients/{client}/resources/sow-project-plan.md (or client Notion) per engagement.

Atomic chain (offering → execution): PLAYBOOK_DEVELOPMENT_PLAN.md §8.2 — Service line → Subservice → Offering → Phase → Deliverable → Ticket.

Retro / Update Log

Date	Engagement	What changed
2026-04-08	—	Initial canonical implementation plan for offering folder (aligned with SOP, implementation playbook, Linear template).

Brainforge Knowledge

Explorer

implementation-plan