Marketo Architect Master cheat sheet

Marketo Engage is a multi-tenant SaaS; all instances share infrastructure but data is logically isolated by subscription.

The core data model: Lead (Person) → Activities → Programs → Campaigns; each object has a unique ID (leadId, activityId, programId, campaignId).

Workspace partitioning separates marketing activities and assets; partitions separate lead records; both are configured in Admin.

API rate limits: REST API 100 calls per 20 seconds per instance; Bulk API 10 concurrent export jobs, 10 concurrent import jobs.

Webhook response time limit: 30 seconds; timeouts count as failures and may be retried.

Engagement programs use a stream-based model with cadence and content; default program types include Engagement, Email, Event, and Default.

Architecture review checklist: data flow diagrams, integration touchpoints, scalability (lead volume, activity volume), security (roles, partitions), and compliance (GDPR, CAN-SPAM).

Custom objects link to leads or companies via a 1:1 or 1:many relationship; each custom object record has a unique ID and up to 3 linked fields.

Lifecycle stages are defined in Admin > Tags; each stage has a type (e.g., Inferred, Known, Engaged, Opportunity) and a name.

Lead lifecycle progression: Anonymous → Known → Engaged → Opportunity → Customer; stages are customizable but must follow a linear order.

Lead score is a numeric field; scores are updated by scoring campaigns that add or subtract points based on behaviors and demographics.

Lead status (in Salesforce) is synced with lifecycle stage via field mapping; changes in either system can trigger updates.

Lead source is a string field; best practice is to use a picklist with values like Organic Search, Paid Search, Webinar, Trade Show.

Data normalization: use a consistent format for country, state, and phone; use validation rules and data enrichment tools.

Lead deduplication: Marketo does not automatically merge duplicates; use smart campaigns with filters like Email Address is not empty and duplicates exist.

Lead assignment: use round-robin or territory-based assignment via smart campaigns and Salesforce assignment rules.

Program types: Engagement, Email, Event, Default; each has a default channel and statuses.

Channels define program statuses and progression; default channels include Email, Webinar, Tradeshow, Content.

Smart campaigns consist of Smart List (filters/triggers) and Flow (actions); triggers evaluate on activity, filters on attributes.

Campaign limits: 500 active smart campaigns per instance; 1000 flow steps per campaign; 1000 filters per smart list.

Engagement programs have streams (up to 25) and cadences (up to 100 days); leads can be in only one engagement program at a time.

Program statuses: each channel defines statuses (e.g., Member, Engaged, Attended, No Show); status changes can trigger campaigns.

Nurture campaigns use engagement programs; content is delivered based on cadence and lead engagement (exhausted, paused, etc.).

Campaign execution: triggers run when activity occurs; filters run on batch schedule; flow steps execute sequentially with optional wait steps.

Lead fields: standard (Email, First Name, Last Name, Company) and custom; custom fields have API names and data types.

Field types: string, integer, boolean, date, datetime, email, phone, URL, currency; field length limits: string 255 chars, text area 32000 chars.

Segmentation: create segments and segmentations in Admin > Segments; leads are assigned to one segment per segmentation based on rules.

Dynamic lists (smart lists) update automatically; static lists are fixed snapshots; both can be used for targeting.

Data hygiene: use smart campaigns to standardize country codes, capitalize names, and validate email addresses.

Duplicate management: use smart campaigns with filters like Email Address is not empty and duplicates exist to merge or flag duplicates.

Data retention: activities are retained for 2 years by default; leads can be deleted but activities remain until purged.

Field management: hide unused fields, set field-level permissions, and use field dependencies to control visibility.

Lead scoring: combine demographic (title, industry) and behavioral (email opens, clicks, web visits) scores; use a scale (e.g., 0-100).

Scoring campaigns: use 'Change Score' flow action; add or subtract points; use 'Score is' filters to trigger alerts.

Score thresholds: define MQL threshold (e.g., 50) and SQL threshold (e.g., 80); route leads to sales when threshold met.

Lead routing: use smart campaigns with 'Assign to' flow action; round-robin via Salesforce assignment rules or Marketo lead assignment.

Nurture strategy: engagement programs with content streams; use cadence (e.g., weekly) and engagement score to adjust delivery.

Lead lifecycle: MQL → SQL → Opportunity → Customer; use lifecycle stage changes to trigger sales alerts and reporting.

Scoring model maintenance: periodically review and adjust scores based on conversion data; use A/B testing for content.

Routing rules: consider territory, industry, company size; use Salesforce queues and assignment rules for complex routing.

Salesforce integration: native sync; field mapping in Admin > Salesforce; sync direction (bi-directional, Marketo only, Salesforce only).

Sync limits: 1000 sync operations per 10 minutes; 100,000 records per sync; use bulk sync for large volumes.

Webhooks: send data to external systems via HTTP POST/GET; response must be within 30 seconds; can be triggered by campaigns.

REST API: 100 calls per 20 seconds; use for real-time lead creation, activity retrieval, and custom object operations.

Bulk API: for large data exports/imports; 10 concurrent jobs; use for initial data loads or periodic syncs.

LaunchPoint: manage integrations (e.g., GoToWebinar, Zoom) via Admin > LaunchPoint; each service has specific configuration.

API authentication: OAuth 2.0 with client credentials; access tokens expire after 1 hour; refresh tokens can be used.

Error handling: monitor API errors via Admin > API Usage; set up alerts for failed syncs and webhook failures.

Revenue Cycle Analytics (RCA): uses revenue stages, success paths, and attribution models; requires setup of revenue stages and cost data.

Attribution models: first touch, last touch, multi-touch (even distribution, weighted); configure in RCA settings.

Program cost: enter period costs for programs; RCA calculates ROI and pipeline attribution.

Report types: Email Performance, Program Performance, Lead Performance, Revenue Explorer; use smart lists for segmentation.

Lead attribution: use acquisition program and acquisition date fields; multi-touch attribution assigns credit to multiple programs.

Dashboard: create custom dashboards with reports; share with stakeholders; schedule report subscriptions.

Data freshness: RCA data refreshes daily; real-time reports (e.g., Email Performance) update immediately.

Metrics: define KPIs (e.g., MQL to SQL conversion rate, cost per lead, pipeline velocity) and track via RCA and Salesforce reports.

GDPR: right to be forgotten; use 'Delete Lead' flow action or API to purge data; maintain consent records.

CAN-SPAM: include unsubscribe link, physical address, and accurate subject line; honor opt-out within 10 days.

Consent management: use 'Email Opt Out' field and subscription center; track consent via custom fields and activity logs.

Data retention policy: set retention periods for leads and activities; use smart campaigns to delete or anonymize data.

Role-based access: define roles and permissions in Admin > Users & Roles; restrict access to sensitive data.

Audit trail: use Admin > Audit Trail to track changes to assets and settings; retain logs for compliance.

Data privacy requests: use 'Privacy' API endpoints to export or delete lead data; log requests for compliance.

Workspace and partition governance: define naming conventions, approval processes, and asset lifecycle management.

User management: create users, assign roles, and set permissions; use SSO for authentication if available.

Workspace and partition setup: create workspaces for different business units; partitions for lead segmentation; assign users to workspaces.

API usage monitoring: track API calls via Admin > API Usage; set up alerts for approaching limits.

Database growth: monitor lead and activity volume; use smart campaigns to archive or delete old data; consider data retention policies.

Performance best practices: limit smart list complexity, avoid excessive flow steps, use batch campaigns for large updates.

Sandbox: Marketo does not provide a native sandbox; use a separate instance for testing; sync with Salesforce sandbox.

Backup and recovery: regularly export data; use API to backup leads and activities; document recovery procedures.

Scalability planning: estimate lead growth, activity volume, and API usage; scale by optimizing campaigns and using bulk operations.