Marketing leaders don’t need another tool—they need a single source of truth that fixes broken attribution, unifies identities across devices, and keeps every platform’s numbers in sync. This 90-day plan shows how to stand up a modern, composable CDP using Segment for collection + identity, Amplitude for product analytics, and AppsFlyer for mobile attribution—then close the loop with Meta Conversions API and Google Enhanced Conversions so ad platforms optimize to your real outcomes (KYC, deposit, LTV), not proxy clicks.
Related reading: For a deeper dive into why identity resolution and CDPs are essential for modern marketing, see our guide on Bridging Data Silos: How Identity Resolution and CDPs Are Transforming Marketing Attribution.
Fintech-specific guidance: If you’re building a regulated funnel (Signup → KYC → Deposit → Loan/Earn), see our Fintech Events, Funnels & ROI Metrics Guide for detailed event schemas and measurement strategies.
What You’ll Ship by Day 90
By the end of this 90-day implementation, you’ll have:
Unified identity across web + app: Deterministic merging of anonymous→known users and cross-device events via Segment Unify; Amplitude retroactively attaches pre-login activity when a user identifies.
One tracking plan, many destinations: Instrument once with Segment, fan out to Amplitude, AppsFlyer, GA, and ad platforms; enforce the spec with Protocols to stop schema drift.
First-party, server-side collection (optional in Phase 2): Route events through your domain and server to reclaim data lost to browser controls.
Closed loop to ad platforms: Deduplicated Meta CAPI events (event_name + event_id) and Google Enhanced Conversions using hashed first-party identifiers.
Finance-grade dashboards in Amplitude: Funnels (Signup→KYC→Deposit), cohort retention, and LTV by source with AppsFlyer post-install data joined in.
The 90-Day Plan (Four Phases)
Phase 0 (Week 0): Readiness & RACI
People: Name an Exec Sponsor, Marketing Owner, Data Lead, Dev Lead.
Scope: Public site, web app, mobile app; destinations: Amplitude (behavior), AppsFlyer (attribution), Meta/Google (ad optimization), warehouse/BI (optional).
Risk log: Identity collisions, missing event params, ad-platform dedupe.
Artifacts you’ll create: Tracking plan v1, UTM rules, environments (dev/stage/prod), backlog of “Day-90 must-haves.”
Tip: Decide now that Segment Protocols will be the single gatekeeper for event names, properties, and allowed values. It can block or flag violations in real time.
Phase 1 (Weeks 1–3): Tracking Plan & Identity Foundations
1) Draft the tracking plan (v1)
Model it around your funnel and revenue events:
signup_started,signup_completedkyc_submitted,kyc_approveddeposit_initiated,deposit_completedloan_requested,loan_approved(or other monetization actions)
For each event define: required properties (e.g., amount, currency, channel, campaign, source_id), types, and allowed values. Store it in Segment and attach to your sources so violations are visible immediately in the Source Schema UI.
2) Identity strategy
- Use Segment Identify everywhere a user can log in or provide email/ID; ensure a consistent
userId. - Use Alias where you must join a pre-login anonymous profile to a logged-in profile.
- Enforce deterministic merge in Unify.
- In Amplitude, set
user_idon login; Amplitude will retro-merge anonymous events to the identified user automatically.
Exit criteria (Week 3): Tracking Plan approved; identity rules agreed; Segment sources live in dev & stage with Protocols enforcement on.
Phase 2 (Weeks 4–6): Instrument Once, Light Up Destinations
3) Implement Segment SDKs
- Web:
analytics.js(load early); move high-value events server-side where feasible to reduce client loss. - Mobile/server: Mirror the same event names/properties.
- Optional but recommended: Segment Managed Custom Domain (e.g.,
events.yourdomain.com) to improve first-party capture.
4) Connect destinations
- Amplitude for product analytics: Create Funnels (Signup→KYC→Deposit) and Retention cohorts by source/campaign.
- AppsFlyer for paid attribution (+post-install data to Amplitude).
- Ads (Meta/Google): Keep client tags in place for now; server-side comes in Phase 3.
Exit criteria (Week 6): Events visible in Amplitude with correct properties and user merge behavior; AppsFlyer receiving installs/post-installs; zero (or explained) Protocols violations.
Phase 3 (Weeks 7–9): QA, Reconciliation, & “Truth Tables”
5) QA the pipeline
Run scripted test journeys across web→app (anonymous→login). Confirm Amplitude funnels match backend counts within expected deltas; investigate any schema violations flagged by Protocols.
6) Reconciliation model (in warehouse/BI or Amplitude Notebooks)
- Build authoritative tables for signups,
kyc_approved, deposits, keyed by your customer ID and mapped to AppsFlyer campaign/source where applicable. - Document attribution window differences so stakeholders know why numbers may vary by tool.
Exit criteria (Week 9): A “Metrics That Matter” page: Signup→KYC→Deposit funnel, 7/30-day retention, and LTV by source/campaign.
Phase 4 (Weeks 10–12): Close the Loop (Server-Side & Conversion APIs)
7) Shift key events server-side (or proxy through your domain)
First-party/server-side collection reclaims signal lost to ITP/ETP/ad-blockers and keeps you privacy-forward. If you use Segment’s managed custom domain, event collection runs over your subdomain.
8) Wire Meta Conversions API with deduplication
Send the same event (e.g., DepositCompleted) from browser and server with a shared event_id so Meta deduplicates correctly (requires matching event_name + event_id).
9) Enable Google Enhanced Conversions / Offline Conversions
Send hashed first-party identifiers (SHA-256: email/phone/address) within 24 hours to improve match rate and bidding accuracy.
Exit criteria (Week 12): Server events flowing; Meta CAPI shows healthy deduplication rates; Google EC match rates and conversion lift visible in Ads.
Governance That Makes the Numbers Match
Numbers disagree when schema drift and ID drift creep in. Bake consistency into the system:
Protocols enforcement: Block unplanned events/invalid properties; keep a clean schema.
Naming rules: One canonical event name per action; consistent, typed properties. Use Segment Spec conventions.
Runbooks: Who can add/change events; deprecation policy; QA checklist before launch.
KPIs to Watch (and Realistic Ranges)
Event delivery rate (client vs server): Server-side should narrow drop-offs caused by browser restrictions; managed first-party domains help capture more events.
Amplitude funnel parity with backend “truth tables” (within known ATT/consent deltas).
Meta CAPI dedupe rate and Google EC match rate trending up after Phase 4.
Roles & RACI (Lightweight)
| Task | Marketing | Data | Engineering | Vendor Tools |
|---|---|---|---|---|
| Tracking plan v1 | A/R | C | C | Segment Docs |
| Identity rules | A | R | C | Segment Unify / Amplitude |
| SDK instrumentation | C | C | R | Segment |
| Protocols enforcement | C | R | R | Segment Protocols |
| Funnels/Retention | R | C | C | Amplitude |
| AppsFlyer hookup | R | C | R | AppsFlyer |
| CAPI/EC setup | A/R | R | R | Meta/Google |
A=Accountable, R=Responsible, C=Consulted.
Your Day-90 Checklist
- ✅ Segment sources live (web, app, server) with Protocols attached; Custom Domain configured (optional).
- ✅ Identity resolution working (anonymous→known merge) in both Segment and Amplitude.
- ✅ Amplitude dashboards: Signup→KYC→Deposit funnel, 7/30-day retention, LTV by source.
- ✅ AppsFlyer → Amplitude post-install data flowing.
- ✅ Meta CAPI deduping correctly (event_name + event_id), Google EC hashing live.
Starter Assets (Swap in Your Brand Terms)
Core Events & Required Properties
| Event | Required properties (examples) |
|---|---|
signup_completed | method, utm_source, utm_campaign, referrer |
kyc_approved | kyc_provider, country, risk_score |
deposit_completed | amount, currency, payment_method, campaign_id, af_install_id? |
loan_approved | amount, term_months, apr |
Destinations Mapping
Amplitude: Full event stream + user properties for funnels/cohorts.
AppsFlyer: Install + post-install events to join paid source to LTV.
Meta CAPI: DepositCompleted with event_id and match keys (email/phone hashed where applicable) for dedupe & match quality.
Google EC: Hashed first-party identifiers with order/transaction IDs.
Why Segment + Amplitude + AppsFlyer is a Pragmatic Trio
Segment Unify gives you a configurable identity graph and lets you instrument once for many destinations (plus Protocols for governance).
Amplitude is built for user-level funnels & retention and merges anonymous→identified activity—a common gap in web-analytics-only stacks.
AppsFlyer stays the source of truth for mobile campaign attribution and can forward to Amplitude for deeper lifecycle analysis.
Common Pitfalls to Avoid
1. Skipping the tracking plan: Without a formal spec, teams end up with duplicate events (e.g., “Signup” vs “signup_completed” vs “SignUpComplete”) and missing required properties. Segment Protocols prevents this by enforcing the plan in real time.
2. Ignoring identity early: If you wait until Phase 3 to think about user ID strategy, you’ll have months of unmergeable anonymous data. Define your identify/alias pattern in Phase 1.
3. Not reconciling with backend truth: Marketing tools will never be 100% accurate due to ad blockers, ATT opt-outs, and consent banners. Build a reconciliation model early so stakeholders understand expected variance.
4. Over-complicating Phase 1: Start with your top 10 revenue-critical events. You can always add more later. Perfection is the enemy of launch.
5. Forgetting server-side deduplication: Meta CAPI and Google EC both require careful event_id matching to avoid double-counting. Test this thoroughly in Phase 4.
Success Metrics: What Good Looks Like
By Day 90, you should see:
- 90%+ event delivery rate for server-side events (vs. ~60-75% client-side in high-blocker environments)
- Amplitude funnel counts within 5-10% of backend truth tables (accounting for known ATT/consent deltas)
- Meta CAPI dedupe rate >80% (meaning browser + server events are properly matched)
- Google EC match rate >70% for hashed email conversions
- Zero unplanned events reaching production (blocked by Protocols)
- Marketing team self-serve on Amplitude dashboards without engineering support
Frequently Asked Questions
Can we really complete a full CDP implementation in 90 days?
Yes, with proper planning and dedicated resources. The 90-day plan assumes you have an executive sponsor, clear ownership across marketing/data/engineering, and can allocate 1-2 engineers plus marketing operations support for the duration. If you're starting from scratch with no tracking plan and limited resources, expect 120-150 days. The key is Phase 0 (Week 0) – proper planning and RACI assignment prevent the delays that stretch projects to 6+ months.
What if we're already using Google Analytics and Facebook Pixel – do we really need Segment?
You can continue using existing tags, but without a CDP like Segment you're instrumenting separately for each tool (Google Analytics SDK, Facebook Pixel, AppsFlyer SDK, etc.), which means: inconsistent event names and properties across platforms, no central schema enforcement, difficult identity resolution across devices, and manual work every time you add a new destination. Segment lets you instrument once and maintain one tracking plan, saving weeks of engineering time and ensuring data consistency.
What's the difference between Segment Protocols and just documenting our tracking plan?
A tracking plan document (spreadsheet or wiki) describes what you want to track. Segment Protocols enforces it in real-time at data collection – it will block or flag events that don't match your schema (wrong event name, missing required property, invalid property type). This prevents bad data from ever reaching your analytics tools. Think of it as 'type checking for your events.' Without enforcement, tracking plans drift as code changes, leading to schema chaos within months.
Do we need to hire a CDP consultant or can we do this ourselves?
You can absolutely do it yourself if you have: a senior data analyst or analytics engineer who understands event schemas and identity resolution, an engineering lead comfortable with SDKs and data pipelines, and a marketing ops person who can own the tracking plan and destination configuration. If you're missing any of these roles or want to move faster, bringing in specialized help (like MetaCTO) can reduce timeline by 30-50% and avoid common pitfalls that add months of rework.
What's the biggest risk that could derail our 90-day timeline?
Identity collisions and schema drift. If you don't define clear identity rules in Phase 1 and enforce schema with Protocols from the start, you'll spend weeks in Phase 3 cleaning up duplicate users and inconsistent events. The second biggest risk is stakeholder misalignment – if marketing, product, and engineering aren't aligned on what events matter and who owns what, decisions slow to a crawl. This is why Phase 0 (Week 0) RACI and governance planning is non-negotiable.
How do we handle iOS ATT restrictions and privacy requirements?
App Tracking Transparency (ATT) on iOS means ~75% of users opt out of sharing their device ID for advertising. Your CDP strategy should include: deterministic identity (email/login-based) wherever possible, server-side event collection to reduce client-side blocking, proper consent management integration (e.g., OneTrust with Segment), and Meta CAPI + Google Enhanced Conversions for first-party data matching. The 90-day plan includes these in Phase 2-4. You won't capture 100% of users, but you'll maximize what's possible within privacy constraints.
What happens after Day 90?
You own and maintain the system. By Day 90, your team should be able to: add new events to the tracking plan and push schema updates via Protocols, create funnels and cohorts in Amplitude without engineering help, connect new destinations in Segment, debug event flow issues, and evolve conversion APIs as ad platforms update. MetaCTO's approach includes training and documentation handoff so you're not dependent on external help for routine changes. For major additions (new products, multi-region expansion), you may bring consultants back in for specific projects.
How much does this cost in software + implementation?
Software costs vary widely. Using startup credits (e.g., $50k Segment credits via AWS/YC), year-1 software can be near $0. Without credits, expect $6k-$25k/year for packaged CDP tiers or warehouse-native stacks. Implementation ranges from $25k-$60k for a pilot (4-6 weeks) to $60k-$120k for production rollout (8-12 weeks) to $120k-$200k for advanced multi-product scenarios. See our CDP Cost Guide for detailed breakdowns.
Want Help?
This plan is how MetaCTO runs “audit → rollout” in 90 days. We can deliver the tracking plan, do the Segment/Amplitude/AppsFlyer wiring, and stand up CAPI/Enhanced Conversions—then train your team to own it going forward.
Budget planning? See our CDP Cost Guide for App Startups for software pricing, implementation ranges, and year-1 budget examples.
Contact us to discuss your CDP implementation timeline and requirements.
Additional Resources
Segment Documentation
- Identity Resolution with Unify
- Protocols: Schema Enforcement
- Analytics.js Quickstart
- Custom Domains for First-Party Data
Amplitude Resources
AppsFlyer Integration
Ad Platform APIs
Looking for the strategic context behind this implementation plan? Read our guide on why identity resolution and CDPs are transforming marketing attribution.