Different starting assumptions
Iterable and Mailchimp both send marketing email, but they assume very different companies.
Iterable assumes you already have a product that generates events: sign-ups, purchases, lessons completed, items viewed, sessions started. Your engineers send those events and user attributes to Iterable through its API or a data pipeline, and your lifecycle team builds journeys that react to them across email, mobile push, SMS, in-app and WhatsApp. It is sold by a sales team, priced by quote and usually implemented over several weeks.
Mailchimp assumes you have a list of people and something to say to them. You import or collect contacts, design a campaign, pick a segment and send. Customer journeys let you automate welcome series and follow-ups. You can sign up on a free plan and upgrade on the pricing page.
If you are asking "Iterable or Mailchimp?", the honest first question is whether your company looks like Iterable's assumption.
Three questions that usually decide it
1. Do you need channels other than email? If your product is a mobile app and push notifications or in-app messages are central to retention, Iterable covers those and Mailchimp does not. If email is 90% of what you send, Iterable's channel breadth is capacity you pay for without using.
2. Do you have event data and someone to maintain it? Iterable's segmentation and triggers are only as good as the events you send it. That means engineering time up front and ongoing ownership when the product changes. Mailchimp works with a CSV and a signup form. Teams that buy Iterable without a data owner often end up sending batch campaigns that Mailchimp could have handled.
3. Can you sign an annual contract without a published price? Iterable's pricing page does not list plans. Our Iterable comparison cites estimates starting around $20,000 per year, plus implementation, but your quote depends on users, channels and support. Mailchimp's Standard plan is about $135/month at 10,000 contacts, Essentials about $110 and Premium about $350, and you can cancel month to month.
If you answered no to two of these, Mailchimp or a mid-market tool is likely the better fit.
How journeys differ in practice
Take a common flow: a user signs up, should complete setup within three days, and gets nudged if they do not.
In Iterable, your app sends a signed_up event and later a setup_completed event. A journey starts on signed_up, waits up to three days for setup_completed, and if it never arrives, sends a push notification first and an email if the push is not opened. You can split-test the nudge copy inside the journey and report on conversion by channel.
In Mailchimp, you can add the user to the audience with a tag at sign-up and start a journey from that tag. To react to setup completion, your app needs to update a tag or merge field (or record an event through the API) and the journey checks for it. There is no push step. The flow works for email, with more manual plumbing and fewer branching options, and journeys require Standard or higher.
Cost beyond the subscription
With Iterable, the subscription is one line. Add engineering time to instrument events, a lifecycle marketer or team to build journeys, implementation services and possibly a CDP or warehouse connector. The total only makes sense when lifecycle messaging drives meaningful revenue or retention.
With Mailchimp, the main hidden cost is list size. Mailchimp counts unsubscribed contacts toward your tier, and a product that syncs every user will climb tiers even if many users rarely get email. Transactional email needs the Mandrill add-on. Advanced segmentation and multivariate testing require Premium.
Pricing reality: what Iterable has to earn back
Use a 10,000-user product as the example. On Mailchimp Standard at about $135/month, email costs roughly $1,620 a year. If an Iterable contract lands near the estimates our comparison cites, around $20,000 a year before implementation, the difference is more than $18,000 a year, plus engineering time to send events.
That gap is not automatically a reason to avoid Iterable. It is the bar the platform has to clear. If push notifications and event-driven journeys lift retention enough to keep a few hundred more paying users a year, a consumer app can clear it easily. If you are sending a weekly newsletter and a welcome series by email, it will not. At small user counts, the math almost always favors Mailchimp or a mid-market tool; at large user counts with several channels, Iterable's value scales and Mailchimp's contact-based bill grows too.
Which situations favor each
| Situation | Better fit | Why |
|---|---|---|
| Consumer mobile app with push and in-app onboarding | Iterable | Push and in-app live in the same journeys as email |
| Weekly newsletter and promotions to a marketing list | Mailchimp | Faster to build, cheaper, no engineering needed |
| Marketplace personalizing emails from a product catalog | Iterable | Catalog and nested user data feed templates |
| Small business with a website, forms and social accounts | Mailchimp | Landing pages, website builder and social tools included |
| Team testing message variants across channels | Iterable | Experiments span channels and journey steps |
| Startup that needs to send its first campaign this week | Mailchimp | Self-serve signup and published pricing |
The data ownership question
Iterable moves a lot of responsibility onto your data. Every trigger, segment and personalization token depends on events and fields your engineers send. When the product team renames an event or changes a property, journeys can silently stop firing. Mature Iterable customers treat the event schema like an API contract: documented, versioned and reviewed when the product changes.
Mailchimp asks far less of you. Most of its data comes from signup forms, imports, tags and store integrations, so marketers can keep it running without an engineer. The trade-off is that it knows less about each person, and you cannot personalize on what it does not know. Before choosing Iterable, name the person who will own the event schema. If nobody can, that is the strongest signal to stay on a simpler tool.
When the list model stops working
Mailchimp's audience model starts to strain in predictable places: when you need to message users based on what they did in the product in the last hour, when the same person should get a push instead of an email depending on their device, or when you want per-user content built from a catalog of thousands of items. Teams often try to patch this with tags and API calls, which works until the tag count and sync jobs become their own maintenance project. If you recognize that pattern, it is time to evaluate event-driven tools, whether Iterable or a mid-market option.
Migration: what actually moves
Mailchimp to Iterable. Contacts, tags and merge fields export as CSV and import cleanly as user fields. The bigger job is sending real-time events from your product, which Mailchimp never needed. Rebuild journeys around those events instead of copying tag-based logic one to one. Recreate templates in Iterable's editor or as HTML. Authenticate your sending domain and plan IP warmup if you are moving to dedicated IPs. Carry over unsubscribes and cleaned (bounced) addresses as suppressions.
Iterable to Mailchimp. Export user profiles and, critically, your unsubscribe and suppression lists before the contract ends. Flatten the attributes you still need into Mailchimp merge fields; nested data and event history will not come across in a usable form. Push, in-app and WhatsApp journeys have no equivalent and need a separate tool or have to be dropped. Rebuild the email parts of journeys as Mailchimp customer journeys and expect simpler branching.
Migration checklist in both directions
| Workstream | Mailchimp to Iterable | Iterable to Mailchimp |
|---|---|---|
| Profiles | Import contacts, tags and merge fields as user fields | Flatten needed attributes into merge fields |
| Events | Instrument real-time events from app and backend | Decide which events become tags or fields, drop the rest |
| Suppressions | Import unsubscribed and cleaned addresses | Export unsubscribes and suppressions before the contract ends |
| Journeys | Redesign around events rather than tags | Rebuild email steps as customer journeys with simpler branches |
| Other channels | Set up push and in-app SDKs if in scope | Replace push, in-app and WhatsApp with other tools or drop them |
| Templates | Recreate in Iterable's editor or as HTML | Recreate in Mailchimp's drag-and-drop editor |
| Domain and IPs | Authenticate domain, plan warmup for dedicated IPs | Authenticate domain, start with engaged segments |
Where Sequenzy fits
Sequenzy sits between the two for one specific case: a SaaS product that wants event-driven email without an enterprise platform. You can trigger sequences from API events and from Stripe, Paddle or Polar billing events natively, send transactional and marketing email from the same account, and pay by emails sent with unlimited contacts, typically $49/month for 60k emails (unlimited subscribers) at 10,000 users.
It is not a replacement for Iterable if you need WhatsApp, enterprise experimentation or deep mobile SDK tooling; Sequenzy's in-app messages and SDKs are lighter. It is also not a replacement for Mailchimp's social posting, ads or website builder. It fits when email is your main lifecycle channel and the data you care about is product usage and billing.
Decision checklist
- Do you need push, in-app or WhatsApp in the same journeys as email? If yes, Iterable is in scope; Mailchimp is not.
- Can you name an owner for the event schema and a team to build journeys? Without both, Iterable's value goes unused.
- Would better lifecycle messaging plausibly earn back a five-figure annual contract? If not, stay self-serve.
- Is your need mostly newsletters, forms and landing pages? Mailchimp is the better fit.
- Is email your main channel and billing your key data? Look at a SaaS email tool before an enterprise contract.
