Category: Newsletters

  • Newsletter referral programs: tracking who sent whom and when credit hits

    Newsletter referral programs: tracking who sent whom and when credit hits

    Newsletter referral programs: tracking who sent whom and when credit hits
    Photo by sue hughes on Unsplash

    Most newsletter platforms now offer built-in referral programs: a subscriber shares a unique link, someone signs up through it, and the original subscriber earns credit toward a reward tier. Simple in theory. Messy in practice.

    Referral systems sit at the intersection of email deliverability, user attribution, and reward fulfillment—and each piece introduces lag, edge cases, and silent failures that can frustrate both you and your readers.

    How referral attribution actually works

    When a subscriber shares their referral link, the platform appends a unique identifier to your signup page URL—usually a query parameter like ?ref=abc123 or a subdomain like abc123.yoursite.com. When someone clicks through and subscribes, the platform writes that relationship to a database table linking the new subscriber ID to the referrer’s ID.

    The credit doesn’t always post immediately. Most platforms batch-process referral credit overnight or on a fixed interval—anywhere from 15 minutes to 24 hours. Beehiiv and MailerLite both delay credit assignment until the new subscriber confirms their email address and survives an initial engagement window, typically 48 to 72 hours. If the new subscriber never opens an email or unsubscribes within that window, the referral credit may never materialize.

    This delay exists to prevent abuse—bot signups, disposable emails, and bulk fake referrals—but it also means your top referrers won’t see their reward progress update in real time. If you promise instant gratification in your referral landing page copy, you’re setting yourself up for support emails.

    Forwarded emails break the chain

    Here’s the silent failure mode nobody warns you about: when a subscriber forwards your email to a friend instead of using the referral link, the new signup loses all attribution. Email clients strip or mangle query parameters when forwarding, and even if the link survives intact, the recipient often lands on your generic signup page without the referral token.

    Some platforms try to salvage this with browser fingerprinting or cookie-based fallback attribution, but those methods fail when the recipient opens the forwarded email on mobile and then subscribes later on desktop. You end up with organic signups that should have been credited referrals, and no clean way to retroactively assign them.

    The workaround: make your referral link the only subscribe path in emails sent to existing subscribers. Remove generic “Subscribe” CTAs from your standard email template and replace them with dynamic referral links. Every platform that supports referral programs offers a merge tag for this—MailerLite uses {$refer_link}, Beehiiv uses {{rlink}}.

    Reward tiers and cap logic

    Most platforms let you define reward tiers—5 referrals earns a free ebook, 25 earns a paid course, 100 earns a one-on-one call—but the backend logic for tier fulfillment varies wildly.

    Some platforms auto-deliver digital rewards via email trigger when a subscriber crosses a threshold. Others flag the subscriber and wait for you to manually fulfill. A few—MailerLite included—require you to export a CSV of referrers above a certain count and handle fulfillment entirely outside the platform.

    Watch for referral caps. Beehiiv lets you set a maximum number of credited referrals per subscriber per month, which prevents a single power-referrer from monopolizing your reward budget. But if you don’t communicate that cap clearly, you’ll face angry emails from someone who sent 50 friends your way and only got credit for 25.

    Check whether your platform counts confirmed subscribers or just signups. ConvertKit’s referral system credits any email address submitted through a referral link, even if it never confirms. That inflates your referral leaderboard with dead emails and costs you rewards you’ll never see ROI on.

    What to check before you launch

    Run a test loop with at least three dummy subscribers before you announce your referral program publicly. Use different devices, browsers, and email clients. Forward the email. Click the link 48 hours later. Unsubscribe one of the dummy signups immediately and see if the credit reverses.

    Document the actual credit delay in your referral landing page FAQ. “Credit typically appears within 48 hours after your friend confirms their subscription” is honest and sets correct expectations.

    Set up a monthly export of your referral leaderboard and cross-check it against your subscriber growth CSV. If you see signups with no attribution but identical signup timestamps and IP geolocation clusters, you’ve got forwarding attribution loss—and you’ll need to decide whether to manually credit those or let them slide.

    Referral programs work, but they’re not fire-and-forget. The mechanics behind them are quieter and slower than the landing page promises, and the edge cases multiply as soon as real humans start sharing links in ways you didn’t script for.

    Want more breakdowns of how newsletter tools actually work under the hood? Subscribe to One Two Three Send—we explain one feature, process, or hidden cost every week.

    Heads up — some links in this article are affiliate links. If you sign up through them, we may earn a small commission at no extra cost to you. We only recommend tools we use ourselves.

  • Mailchimp segment sync lag: when audience filters take 90 minutes

    Mailchimp segment sync lag: when audience filters take 90 minutes

    Mailchimp segment sync lag: when audience filters take 90 minutes
    Photo: Mailchimp via Wikimedia Commons (CC BY-SA 4.0)

    If you’ve ever built a segment in Mailchimp based on subscriber activity—opens, clicks, sign-up date, or custom field values—and then wondered why subscribers aren’t appearing where they should, you’ve hit the platform’s segment sync delay.

    Mailchimp segments aren’t live queries. They’re pre-calculated lists that refresh on a schedule you don’t control. For solo operators running time-sensitive campaigns or automation sequences, that lag can break workflows in ways that aren’t obvious until someone replies asking why they got the wrong email.

    How Mailchimp calculates segments

    When you create a segment using conditions—”opened any campaign in the last 30 days,” “signed up before January 1,” “has tag X but not tag Y”—Mailchimp evaluates those conditions in batch jobs, not in real time.

    The refresh interval varies by account size and server load, but the typical window is 60 to 90 minutes. During peak sending hours (weekday mornings in US time zones), that window can stretch longer.

    This means if a subscriber opens your email at 9:00 a.m. and you send a follow-up campaign at 9:15 a.m. to a segment of “opened in the last hour,” they won’t be included. The segment hasn’t re-evaluated yet.

    Tags, by contrast, apply instantly. If you add a tag via automation or manual action, it’s available immediately for campaign targeting or automation triggers.

    What triggers a segment refresh

    Mailchimp doesn’t publish the exact refresh logic, but based on operator reports and support documentation, segments re-evaluate:

    • Every 60–90 minutes during normal load
    • When you manually load the segment preview in the campaign builder (this forces a one-time refresh for that view only—it doesn’t update the underlying segment data)
    • Before a scheduled campaign sends, if the segment is used as the recipient list (this is inconsistent and shouldn’t be relied on)

    There’s no manual “refresh now” button. You can’t force a global recalculation.

    When lag breaks workflows

    The most common failure mode: behavioural follow-ups.

    Let’s say you send a product announcement at 8:00 a.m. You want to send a second email at 10:00 a.m. to everyone who opened the first one. You build a segment: “opened campaign [Product Announcement] in the last 3 hours.”

    At 10:00 a.m., that segment might still reflect data from 8:30 a.m. Subscribers who opened at 9:45 a.m. won’t be in the list. You either send to an incomplete audience or delay the campaign and hope the next sync catches up.

    The same issue hits automation sequences that rely on segment conditions as entry or exit rules. A subscriber might meet the criteria but not enter the automation for 90 minutes—or exit too late and receive an email they shouldn’t.

    When to use tags instead

    If timing matters, use tags and automation to apply them immediately:

    • Set up an automation that triggers when someone opens a specific campaign, then applies a tag (“Opened Product Announcement”).
    • Target your follow-up campaign to that tag, not a segment condition.
    • The tag applies in near-real time (under 5 minutes in most cases), so your 10:00 a.m. send includes everyone who opened by 9:55 a.m.

    Tags cost you in list complexity—you’ll accumulate more of them, and you’ll need a cleanup workflow to remove outdated tags—but they give you control over timing.

    For static conditions that don’t change often (sign-up date, geographic location, subscription tier), segments work fine. For behavioural targeting within a 24-hour window, tags are the only reliable option.

    The non-obvious workaround

    If you’re locked into using segments and can’t refactor to tags, pad your timing assumptions by two hours.

    Instead of “opened in the last 3 hours,” use “opened in the last 5 hours.” Instead of scheduling a follow-up 2 hours after the initial send, wait 4 hours. This accounts for both the segment sync lag and any delivery delays on the original campaign.

    It’s not elegant, but it’s more reliable than hoping Mailchimp’s batch job runs on your schedule.

    If you’re running a content business where timing matters—launch sequences, event-driven follow-ups, or behaviour-based upsells—segment sync lag is a tax on execution speed. You can work around it, but it’s worth knowing the cost before you build a workflow that assumes real-time data.

    Hit reply if you’ve found a segment refresh pattern we missed—we’re collecting operator notes on timing across ESPs.

  • ConvertKit’s creator network referral split: how it divides revenue

    ConvertKit’s Creator Network lets your readers refer new subscribers to your newsletter—and if those subscribers convert to paid, you split the revenue with the referrer. It sounds simple until you hit the first payout cycle and realise the platform’s doing more math than you expected.

    Here’s how the feature actually works, when the money moves, and one edge case that catches most operators off guard.

    How the revenue split is calculated

    When someone joins your paid newsletter through a Creator Network referral link, ConvertKit splits the subscription revenue 50/50 between you (the creator) and the referrer. That’s the default. You can adjust it in your Creator Network settings, but most operators leave it at 50% because changing it requires manual coordination with referrers.

    The split applies to recurring revenue, not just the first payment. If a referred subscriber stays for twelve months at $10/month, the referrer earns $5/month for the entire subscription lifetime. ConvertKit doesn’t cap referral earnings by time or total amount—the split continues as long as the subscriber remains active.

    One important detail: the split is calculated after ConvertKit’s platform fees. If you’re on the Creator Pro plan and paying ConvertKit’s processing fees (roughly 2.9% + 30¢ per transaction), those fees come out first. Then the remaining amount is split between you and the referrer.

    Example: a $10/month subscription after fees nets roughly $9.41. You and the referrer each get $4.70. Not $5.

    When payouts actually happen

    ConvertKit doesn’t pay referrers immediately. Referral earnings are held for 30 days after the original payment clears. This is a standard chargeback buffer—if the subscriber disputes the charge or cancels within the first month, ConvertKit claws back the referral credit before it’s paid out.

    After the 30-day hold, ConvertKit processes referral payouts on a monthly cycle. If you’re the referrer, you’ll see pending earnings in your Creator Network dashboard, but the money won’t hit your account until the next payout window.

    For creators (you), the revenue split happens in real time on your dashboard, but the net amount you receive reflects the referrer’s share immediately. You won’t see $10 and then lose $5—you’ll see $4.70 deposited from the start.

    What happens when a referred subscriber cancels

    This is where it gets messy.

    If a referred subscriber cancels, the referral split stops immediately. No future revenue, no future referral earnings. That part is straightforward.

    But here’s the edge case: if the subscriber cancels within the first 30 days—before the referrer’s first payout clears—ConvertKit voids the referral earning entirely. The referrer gets nothing, and you (the creator) retroactively receive the full subscription amount for that period.

    If the subscriber cancels after the 30-day hold, the referrer keeps whatever they’ve already been paid, but future splits stop. You don’t get back the referrer’s share from prior months.

    This creates an incentive problem: referrers are motivated to send high-intent subscribers who stick around, because early cancellations wipe out their earnings. If you’re seeing a lot of Creator Network referrals that churn in week two, the referrer’s probably casting too wide a net.

    One non-obvious tip: track referral source quality separately

    ConvertKit’s Creator Network dashboard shows you total referrals and total revenue, but it doesn’t break down which referrers are sending subscribers who actually stay. You’ll need to export your subscriber list and cross-reference referral sources with churn rates manually.

    If you’re running a paid newsletter and relying on Creator Network traffic, build a monthly spreadsheet that tracks:

    • Referrer name
    • Number of conversions
    • 30-day retention rate
    • 90-day retention rate

    This tells you which referrers are worth cultivating and which ones are sending looky-loos who bail before the first payout even clears. You can’t change the 50/50 split on a per-referrer basis, but you can stop promoting referral links from low-quality sources.

    When to use Creator Network vs. affiliate tools

    ConvertKit’s Creator Network is built for newsletter-to-newsletter referrals. It works well if your audience overlaps with other creators in your niche and you want a low-friction way to cross-promote.

    But if you’re paying affiliates outside the newsletter world—bloggers, YouTubers, podcasters—you’re better off using a dedicated affiliate tool like Rewardful or PartnerStack. Those platforms let you set custom commission rates, track conversions across multiple products, and integrate with Stripe directly.

    Creator Network is convenience, not flexibility. If you need more control, you’ll outgrow it fast.

    Want more breakdowns like this? Subscribe to One Two Three Send for weekly deep dives on the tools that run your online business—no fluff, just the mechanics that matter.

  • Beehiiv’s 3D analytics break when subscribers use Gmail aliases

    Beehiiv‘s 3D analytics promise something most newsletter platforms don’t: individual subscriber-level tracking. You can see exactly who opened, clicked, and engaged with your last six issues. It’s one of the platform’s standout features, especially for operators running sponsor-dependent publications where engagement proof matters.

    But there’s a quiet edge case that throws off the numbers: Gmail aliases. Specifically, the plus-addressing trick that lets users append a label to their address—like [email protected]. Gmail delivers it to [email protected], but Beehiiv treats them as two separate subscribers.

    That means your 3D analytics can show wildly different engagement profiles for what is, in reality, the same person.

    How 3D analytics track subscribers

    Beehiiv’s 3D system logs opens, clicks, poll responses, and referrals at the email-address level. Each address gets a timeline of behavior. You can filter by engagement score, see who your most active readers are, and build segments based on individual actions.

    The problem starts during import or sign-up. If someone subscribes using [email protected] and later re-subscribes (or gets manually added) as [email protected], Beehiiv registers two profiles. Both receive your sends. Both log separate opens and clicks. Your total subscriber count inflates, and your engagement data splits across phantom accounts.

    This isn’t unique to Beehiiv—most ESPs treat email strings as unique identifiers—but it matters more here because the 3D dashboard surfaces individual behavior. When you’re trying to identify your top 50 engaged readers for a beta offer or sponsor case study, duplicate profiles dilute the signal.

    Where Gmail aliases break reporting

    The most common scenario: a reader subscribes on mobile using autofill (which often suggests the base Gmail address), then signs up again from desktop using a tagged version they created for inbox filtering. Beehiiv doesn’t merge them. Both profiles exist. Both show partial engagement.

    If you’re running a referral program, this gets messier. Beehiiv credits referrals to the specific email address used in the referral link. If your top advocate shares their +newsletters alias link but their primary profile is untagged, their referral count splits. The leaderboard shows two entries, neither reflecting their total effort.

    Poll responses fragment the same way. A reader who answers a poll from one alias and later responds from another appears as two participants. If you’re using poll data to segment or personalize future sends, you’re working with incomplete profiles.

    What to do about it

    Beehiiv doesn’t auto-merge Gmail aliases. You can manually merge subscribers in the dashboard—go to Audience → Subscribers, select two profiles, and choose Merge—but it’s reactive, not preventive. You won’t know duplicates exist until you spot them in reports or someone replies asking why they’re getting double sends.

    The cleanest prevention: normalize email addresses at import. Strip everything between + and @ before uploading CSVs. Most spreadsheet tools can handle this with a formula. In Google Sheets:
    =REGEXREPLACE(A2, “+.*@”, “@”)
    Apply it to your email column before importing, and you’ll collapse aliases to their base address.

    If you’re importing from another ESP that already has alias duplication, run a deduplication pass before migration. Export your list, normalize addresses, then re-import. You’ll lose the duplicate profiles but preserve the engagement history tied to the base address (assuming the base address exists in your export).

    For ongoing management, check your subscriber growth report monthly. If you’re seeing consistent small upticks without corresponding traffic or form submissions, aliases might be inflating the count. Filter by recent sign-ups and scan for near-identical addresses.

    When aliases actually help

    Not all aliasing is a problem. Some operators intentionally use Gmail plus-addressing to track where sign-ups originate—embedding a source tag in the subscribe form’s autofill value. If you’re doing this, document it and exclude those tagged addresses from engagement analysis. Treat them as tracking instruments, not reader profiles.

    Beehiiv’s 3D analytics are still worth using. Individual-level tracking beats aggregate stats when you’re pitching sponsors or building tight audience segments. Just know that Gmail’s flexibility creates data noise you’ll need to clean manually.

    Want more tool breakdowns like this? Subscribe to One Two Three Send for weekly deep-dives on the platforms and features that power online businesses. No fluff, just the edge cases and fixes you won’t find in help docs.

    Heads up — some links in this article are affiliate links. If you sign up through them, we may earn a small commission at no extra cost to you. We only recommend tools we use ourselves.

  • ConvertKit automation triggers fire twice—when and why

    ConvertKit’s visual automation builder is powerful, but it has one behavior that trips up nearly every operator the first time they encounter it: automations can trigger the same sequence or action more than once for the same subscriber.

    This isn’t a bug. It’s how the platform handles conditional branching and re-entry logic. But if you don’t understand when and why it happens, you’ll send duplicate emails, apply tags twice, or fire webhook actions that were only supposed to run once.

    Here’s how to structure your automations so they behave the way you expect.

    What causes duplicate triggers

    ConvertKit automations are event-driven. Every time a subscriber meets a trigger condition—subscribing to a form, clicking a link, being tagged—the automation evaluates whether to run.

    The problem arises when a subscriber re-enters an automation they’ve already completed. By default, ConvertKit allows re-entry unless you explicitly configure the automation to block it.

    Common scenarios where this happens:

    • A subscriber clicks the same link twice in two different emails, and both clicks trigger the same automation.
    • You tag someone manually, then a separate automation tags them again with the same tag, re-triggering a tag-based automation.
    • A form submission triggers an automation, and you later re-import that subscriber via CSV, which fires the form’s “new subscriber” trigger a second time.

    ConvertKit doesn’t deduplicate these events automatically. If the trigger fires, the automation runs—even if the subscriber has already been through it.

    How to prevent re-entry

    ConvertKit gives you two ways to control re-entry: automation-level settings and conditional branching within the automation itself.

    Automation-level re-entry settings: When you create or edit an automation, you can toggle whether subscribers are allowed to re-enter after completing it. This is buried in the automation’s settings panel (top-right corner of the builder). If you turn off re-entry, a subscriber who completes the automation will never trigger it again, even if they meet the trigger condition multiple times.

    This works well for one-time sequences: welcome emails, onboarding flows, or product-launch announcements. Once someone’s been through it, they don’t need to see it again.

    Conditional branching: For automations that should sometimes re-run but not always, use ConvertKit’s “Conditions” step. You can add a condition at the top of your automation that checks whether the subscriber already has a specific tag. If they do, branch them to an empty path that does nothing. If they don’t, proceed with the sequence and apply the tag at the end.

    This approach gives you fine-grained control. For example, if you’re running a link-click automation that sends a resource, you can check for a “resource_sent” tag before delivering it. The automation can fire as many times as the subscriber clicks, but the email only goes out once.

    When duplicate triggers are intentional

    Not all duplicate triggers are mistakes. Some automations are designed to run repeatedly.

    If you’re tracking engagement—say, tagging subscribers every time they click a specific link—you want the automation to fire on every click. You’re not sending an email; you’re incrementing a behavioral signal.

    Similarly, if you’re using ConvertKit’s “Events and Triggers” to fire webhooks to external tools (like Zapier or Make), you may want every instance of the trigger to pass through. A subscriber clicking a “buy now” link twice might indicate two separate purchase intents, and your external workflow should handle both.

    In these cases, leave re-entry enabled and structure your automation to handle repeat runs gracefully. Use tags or custom fields to track state, and let your downstream logic decide what to do with duplicate events.

    What to check if you’re seeing duplicates

    If you’re already seeing duplicate sends or actions, audit your automations in this order:

    • Check the automation’s re-entry setting. If it’s on, decide whether it should be.
    • Look for overlapping triggers. Two automations with the same trigger (e.g., “subscriber added tag X”) will both fire. Consolidate them or add conditions to prevent overlap.
    • Review your tagging logic. If multiple automations or manual actions apply the same tag, every tag application will re-trigger tag-based automations.
    • Check your form settings. ConvertKit’s “subscribe on form submit” trigger fires every time the form is submitted, even if the email is already in your list. If you’re re-importing subscribers or using the same form for multiple purposes, this can cause unexpected re-entry.

    ConvertKit’s automation history (under “Subscribers” → individual subscriber profile → “Automation History”) shows every automation run for that subscriber, including timestamps. If you see the same automation listed multiple times, trace back to the trigger event and check your re-entry settings.

    Bottom line

    ConvertKit’s automation re-entry behavior is consistent once you know the rules, but it’s not obvious from the interface. Treat every automation as re-entry-enabled by default, and explicitly configure the ones that should only run once.

    If you’re building complex flows—multi-step onboarding, behavioral segmentation, or event-driven sequences—test with a dummy subscriber and watch the automation history. You’ll catch duplicate triggers before they reach your list.

    Got a ConvertKit automation question? Reply to this email—I read every one.

  • Newsletter subscriber imports fail at commas—here’s the fix

    Newsletter subscriber imports fail at commas—here’s the fix

    Newsletter subscriber imports fail at commas—here's the fix
    Photo by Markus Winkler on Unsplash

    You export 8,000 subscribers from your old platform. You upload the CSV to your new ESP. The import runs. You check the dashboard: 7,847 contacts created, 153 errors.

    You open the error log. Every single failed row has a name field with a comma in it—business titles like “Smith, CPA” or “Jones, LLC” or people who entered their name last-name-first.

    CSV stands for comma-separated values. The format uses commas as delimiters. When your data contains commas, parsers get confused unless you handle it correctly. Most ESP import tools don’t tell you this up front, and most export tools don’t encode properly by default.

    Why commas break imports

    A typical CSV row looks like this:

    [email protected],John Smith,2026-09-15

    Three fields: email, name, signup date. The parser splits on commas and assigns each chunk to a column.

    Now add a comma inside the name field:

    [email protected],Smith, John,2026-09-15

    The parser sees four fields. It tries to map “Smith” to the name column and “John” to the date column. Type mismatch. Row rejected.

    The CSV spec solves this with double-quotes. Wrap any field containing a comma (or a line break, or another double-quote) in quotes:

    [email protected],"Smith, John",2026-09-15

    Now the parser treats everything between the quotes as a single field. Most ESPs support this—but only if the quotes are there.

    How to fix your export before import

    If you’re exporting from a platform that gives you a raw CSV download, open the file in a spreadsheet app (Excel, Google Sheets, LibreOffice Calc) before uploading it to your new ESP.

    Look at the name column. If any cells contain commas, the export should have wrapped them in quotes automatically. If it didn’t, you need to re-save the file with proper encoding.

    In Excel or Google Sheets: File → Download → CSV or Save As → CSV (UTF-8). Both will auto-quote fields with commas. Do not hand-edit the raw CSV in a text editor unless you know exactly what you’re doing—it’s easy to miss a trailing quote or escape character.

    In Google Sheets specifically, use File → Download → Comma Separated Values (.csv). The “Tab Separated Values” option won’t help you here, and the “Microsoft Excel” export creates an .xlsx file, not a CSV.

    When your ESP’s importer still chokes

    Some older or budget-tier ESPs don’t fully implement CSV quoting rules. If you’ve properly quoted your fields and rows still fail, try these fallbacks:

    • Strip commas from the name field entirely. Replace “Smith, CPA” with “Smith CPA” or “Smith (CPA)”. You lose formatting, but you gain a clean import.
    • Use a pipe or semicolon delimiter instead. A few platforms (MailerLite and Brevo both support this) let you upload with a different separator. Export your spreadsheet as tab-separated or pipe-separated, then select the matching delimiter in the import wizard.
    • Split the import into batches. Filter out rows with commas in names, import the clean batch first, then manually add the problematic subscribers via the ESP’s web form or API. Tedious, but it works when automation fails.

    One non-obvious fix: use the API instead

    If you’re moving more than 10,000 subscribers or you’re doing this migration as a service for clients, skip the CSV upload UI entirely. Most ESPs offer a bulk-import API endpoint that accepts JSON. JSON doesn’t have delimiter ambiguity—commas inside strings are fine, and the structure is unambiguous.

    You’ll need a script (Python + the requests library works well), but you can process your CSV locally, validate each row, and POST clean JSON payloads in batches of 500–1,000 at a time. Beehiiv, Brevo, and MailerLite all document their import APIs with sample code.

    The API route also gives you real-time error handling. If a row fails, you get an immediate error response with the reason. No waiting 20 minutes for a bulk upload to finish, then digging through a generic error file.

    For a one-time migration, the CSV upload UI is faster. For repeat migrations, agency work, or large lists, invest two hours in learning the API. It pays off quickly.

    Got a migration coming up? Reply and tell us which platforms you’re moving between—we’ll cover the specific export quirks in a future issue. And if you found this useful, forward it to anyone still wrestling with CSV uploads.

    Heads up — some links in this article are affiliate links. If you sign up through them, we may earn a small commission at no extra cost to you. We only recommend tools we use ourselves.

  • ConvertKit vs. MailerLite vs. Beehiiv: price breaks at 5k, 10k, 50k

    If you’re running a content business and crossing 5,000 subscribers, you’ve probably started doing the math on platform costs. The difference between ConvertKit, MailerLite, and Beehiiv isn’t just monthly pricing—it’s what you get at each tier, what breaks when you scale, and where each platform forces you to upgrade or migrate.

    Here’s an operator-level comparison at the tiers that matter: 5,000, 10,000, and 50,000 subscribers.

    Pricing at scale

    At 5,000 subscribers:

    • ConvertKit: $66/month (Creator plan), unlimited sends
    • MailerLite: $45/month (Growing Business), unlimited sends
    • Beehiiv: $99/month (Scale plan), unlimited sends

    At 10,000 subscribers:

    • ConvertKit: $100/month
    • MailerLite: $75/month
    • Beehiiv: Still $99/month—pricing doesn’t change until 100k

    At 50,000 subscribers:

    • ConvertKit: $208/month
    • MailerLite: $225/month
    • Beehiiv: Still $99/month

    Beehiiv’s flat-rate structure wins on raw cost above 10k subscribers, but that’s not the whole story.

    Feature trade-offs you’ll actually notice

    ConvertKit gives you visual automation workflows, robust tagging, and subscriber scoring at every paid tier. If you’re running a funnel with lead magnets, tripwires, or multi-step onboarding, ConvertKit’s automation builder is the most operator-friendly. The downside: no native referral program, no ad network, and you’ll need Zapier or custom code for anything beyond email.

    MailerLite includes landing pages, pop-ups, and a drag-and-drop site builder in every plan. You can run a lightweight site-plus-newsletter business without WordPress. The automation is simpler than ConvertKit’s, but it works for most workflows. Where MailerLite falls short: no built-in monetization tools, no recommendation network, and segmentation gets clunky above 20k subscribers.

    Beehiiv bundles a referral program, ad network access (on Scale and above), polls, and a recommendation engine. If you’re treating your newsletter as a standalone media property, Beehiiv’s feature set supports that model out of the box. The catch: automations are basic—think “send this email after X days” rather than ConvertKit’s branching logic. If you need complex funnels, you’ll bolt on external tools.

    Who each is best for

    Pick ConvertKit if you’re selling digital products, running evergreen sequences, or need tight control over subscriber journeys. It’s the best tool for creators who treat email as a funnel, not just a broadcast channel. You’ll pay more per subscriber, but the automation flexibility justifies it if your revenue model depends on segmentation and timing.

    Pick MailerLite if you’re early-stage, budget-sensitive, and want an all-in-one starter stack. The site builder and pop-up tools let you skip a separate landing-page tool. It’s ideal for solopreneurs who want simplicity and don’t need advanced monetization features yet. Expect to migrate or supplement when you cross 25k subscribers and need better segmentation.

    Pick Beehiiv if you’re running a publication-style newsletter where growth, referrals, and sponsorships matter more than product funnels. The flat pricing makes budgeting predictable, and the ad network can offset platform costs once you’re approved. You’ll sacrifice automation depth, but if your business model is “grow audience, sell ads or subscriptions,” Beehiiv’s feature set aligns.

    Migration friction points

    All three platforms let you export subscriber lists as CSV, but custom fields and tag structures don’t map cleanly. If you’ve built automations in ConvertKit, expect to rebuild them manually in Beehiiv or MailerLite—there’s no one-click migration for workflows.

    Beehiiv’s referral program data doesn’t export. If you’ve grown 10k subscribers via referrals and want to migrate, you’ll lose the referral tree and reward history.

    MailerLite’s site-builder content lives inside their platform. Migrating to ConvertKit or Beehiiv means rebuilding landing pages elsewhere.

    Want more tool breakdowns like this? Subscribe to One Two Three Send—we compare platforms, dissect pricing, and publish the operator-level details that marketing pages skip.

    Heads up — some links in this article are affiliate links. If you sign up through them, we may earn a small commission at no extra cost to you. We only recommend tools we use ourselves.

  • Transactional email deliverability: why marketing ESPs tank it

    Transactional email deliverability: why marketing ESPs tank it

    Transactional email deliverability: why marketing ESPs tank it
    Photo by Miguel Ángel Padriñán Alba on Unsplash

    Most solo operators send two types of email through the same platform: newsletters and transactional messages. That’s a mistake that shows up in your inbox placement rate—and you won’t see it until a customer complains they never got their password reset.

    Transactional email—password resets, order confirmations, login codes, payment receipts—requires different infrastructure than marketing email. The delivery expectations are stricter, the failure modes are different, and the IP reputation dynamics don’t overlap.

    Here’s what changes when you split them, and when it’s worth the overhead.

    Marketing and transactional email use different reputation signals

    When you send a newsletter, mailbox providers evaluate your sender reputation over days or weeks. A few spam complaints or low engagement rates get averaged into a rolling score. You can recover from a bad send.

    Transactional email doesn’t get that grace period. A password reset that doesn’t arrive in thirty seconds is a failed transaction. Mailbox providers know this. They evaluate transactional senders on speed, consistency, and complaint rate—but complaints on transactional mail are rare, because recipients explicitly requested the message.

    When you send both through the same IP pool, your newsletter engagement rate drags down your transactional delivery. A single newsletter with weak engagement can delay order confirmations for hours while your shared IP gets throttled by Gmail.

    Postmark, which specializes in transactional delivery, maintains separate IP pools and enforces a strict no-marketing policy for exactly this reason. Their average transactional delivery time is under two seconds because they never let marketing volume pollute the reputation of those IPs.

    Volume spikes break transactional delivery when mixed with marketing

    Newsletter platforms are built to handle scheduled batch sends. You queue 10,000 emails at 9 a.m. and they go out over twenty minutes. That’s expected behavior.

    Transactional email is bursty and unpredictable. A product launch might trigger 500 order confirmations in three minutes. A password breach forces 2,000 reset emails in an hour. The platform needs to send immediately, not queue behind your weekly newsletter.

    When you mix both on a single ESP, you create a priority conflict. Beehiiv and MailerLite both handle transactional sends, but they’re optimized for scheduled marketing volume. If your newsletter is mid-send and a customer checks out, that order confirmation might wait in line.

    Dedicated transactional platforms route urgent messages through priority queues. Postmark guarantees delivery attempts within ten seconds. Brevo offers separate IP pools for transactional vs. marketing, but you need to configure them—it’s not the default.

    Compliance and logging requirements differ

    Marketing email in 2026 requires an unsubscribe link in every message, a physical mailing address, and compliance with CAN-SPAM or GDPR consent rules depending on your audience location.

    Transactional email is exempt from most of those rules—because it’s fulfilling a user-initiated action. You don’t need an unsubscribe link in a password reset. You don’t need consent to send an invoice.

    But mixing them on the same platform means your transactional templates might inherit marketing-compliance features you don’t need. Worse, some platforms apply the same suppression list to both. If a user unsubscribes from your newsletter, they might also stop receiving order confirmations.

    Separate platforms let you enforce different retention and logging policies. Transactional sends often need longer log retention for audit or dispute resolution—Postmark keeps logs for 45 days, longer than most marketing ESPs.

    When to split, and what it costs

    If you’re sending fewer than 100 transactional emails per month, the overhead of a second platform isn’t worth it. Stay on your marketing ESP and monitor delivery.

    Split when:

    • You send more than 500 transactional emails per month
    • Customers report missing password resets or payment confirmations
    • You run a product with user signups, checkouts, or account actions that require immediate email
    • Your newsletter volume fluctuates and you need guaranteed transactional speed

    Postmark charges $15/month for 10,000 transactional emails, with delivery logs and dedicated IPs included. Brevo offers 300 free transactional emails per day on their free tier, then $25/month for higher volume with separate IP pools.

    You’ll integrate via SMTP or API. Most platforms—WordPress, Shopify, custom apps—support both. SMTP is easier for legacy systems; API gives you more granular delivery webhooks and retry control.

    Migration takes two hours, not two days

    Moving transactional email off your marketing ESP is simpler than migrating your newsletter list. You’re changing a configuration setting, not exporting CSVs.

    In WordPress, install the Postmark or Brevo plugin, authenticate with your API key, and route wp_mail() calls through the new service. In a custom app, swap your SMTP credentials or API endpoint. Test with a password reset and a sample order confirmation.

    The hardest part is updating DNS records—you’ll need to add new SPF and DKIM entries without breaking your existing marketing setup. Most transactional platforms provide a DNS validation tool that checks your records before you go live.

    Once it’s running, monitor your delivery rate in the transactional platform’s dashboard. If you’re seeing 99%+ delivery within ten seconds, you’ve fixed the problem your marketing ESP was quietly causing.

    Want more infrastructure breakdowns like this? Subscribe to One Two Three Send and get operator-focused tool explainers every week—no fluff, just the technical details that affect your delivery and revenue.

    Heads up — some links in this article are affiliate links. If you sign up through them, we may earn a small commission at no extra cost to you. We only recommend tools we use ourselves.

  • Stop trusting open rates—track reply rates instead

    Open rates have been broken since iOS 15 dropped Mail Privacy Protection in 2021. By 2026, most email platforms report inflated open metrics—often 20–40 percentage points higher than genuine engagement. Yet operators still use open rate as their primary health metric.

    Reply rate is the better signal. It’s harder to game, immune to privacy protection prefetch, and directly correlated with reader trust. If someone hits reply, they read your email. If your open rate is 68% but your reply rate is 0.02%, you have a surface-level audience, not an engaged one.

    Why open rates lie more now than ever

    Apple Mail Privacy Protection prefetches email content—including tracking pixels—whether the recipient opens the message or not. Gmail’s image proxy caching does something similar. Microsoft Outlook’s Focused Inbox prerenders previews. The result: platforms record an “open” even when the email was never seen by a human.

    For operators sending to audiences with high Apple Mail adoption (common in B2C wellness, design, and lifestyle niches), reported open rates routinely exceed 60%. That number doesn’t reflect intent. It reflects infrastructure.

    Click-through rate is more reliable than open rate, but it only captures a narrow behavior: the subset of readers who both engage and want to leave your email. Reply rate captures everyone who wants to continue the conversation inside the inbox.

    What reply rate actually measures

    Reply rate = (unique reply senders) / (delivered emails) over a given period. Most ESPs don’t surface this metric in dashboards. You’ll need to calculate it manually or use a dedicated tool.

    Postmark tracks replies natively if you configure inbound routing. Beehiiv doesn’t offer reply tracking in-platform as of mid-2026, but you can pipe replies into a shared inbox (Gmail, Front, Missive) and tag them by campaign. MailerLite requires a webhook setup to catch inbound mail.

    Typical reply rates for well-engaged lists:

    • 0.5–2% for broadcasting newsletters (one-to-many)
    • 3–8% for onboarding sequences or high-touch courses
    • 10–20% for tiny lists under 500 where the operator responds personally

    If you’re under 0.2%, your audience isn’t reading—or your writing doesn’t invite conversation.

    How to increase reply rate without begging

    Don’t end every email with “just hit reply!” That’s performative and readers ignore it. Instead, structure your content to naturally prompt response.

    Ask a single, specific question. Not rhetorical. Not broad. “What’s the biggest bottleneck in your content workflow right now?” beats “How’s your week going?”

    Share a half-formed opinion. Readers reply to refine, agree, or argue. “I think most operators over-index on SEO and under-invest in email” will get more replies than a polished thesis.

    Offer a binary choice. “I’m writing a guide on either WordPress caching or CDN setup next week—reply A or B.” Low friction, clear action, built-in reason to respond.

    Reply to every reply in the first 30 days. It trains your audience that replying works. After that, you can batch responses weekly or spotlight interesting replies in the next send.

    When reply rate doesn’t matter

    If you’re running a pure news digest, a curated link roundup, or a high-volume daily brief, reply rate isn’t your north star. Those formats succeed on speed and brevity, not conversation.

    Same if you’re monetizing exclusively through affiliate clicks or display ads. Your business model doesn’t require dialogue. Click-through rate and revenue per send matter more.

    But if you’re building toward courses, coaching, or any offer that requires trust, reply rate is the early indicator. It tells you who’s paying attention before you ask them to pay money.

    Start tracking reply rate this week. Create a spreadsheet. Column A: send date. Column B: delivered count. Column C: unique reply senders. Column D: reply rate. Update it after every send. If the number trends down over 8–10 emails, your content is drifting away from your audience.

    Want more tactical breakdowns like this? Subscribe to One Two Three Send and get one operator-focused article every day.

    Heads up — some links in this article are affiliate links. If you sign up through them, we may earn a small commission at no extra cost to you. We only recommend tools we use ourselves.

  • Mailchimp migration exports: what gets lost in the CSV

    Mailchimp migration exports: what gets lost in the CSV

    Mailchimp migration exports: what gets lost in the CSV
    Photo: Mailchimp via Wikimedia Commons (CC BY-SA 4.0)

    If you’ve outgrown Mailchimp or decided to move to a platform with better economics, you’ll eventually hit the export button and download a CSV of your subscriber list. That file will contain email addresses, names, and maybe a few custom fields. What it won’t contain: most of the operational context that makes your list work.

    Mailchimp’s export is designed for portability, not fidelity. The platform strips out automation state, tag relationships, segment definitions, and engagement metadata that doesn’t fit neatly into a flat file. If you import that CSV into MailerLite, Beehiiv, or any other platform without documenting what’s missing, you’ll spend weeks rebuilding workflows from memory.

    Here’s what actually gets lost, and what you need to capture before you click export.

    Tags export as a single concatenated column

    Mailchimp allows unlimited tags per subscriber. When you export, all tags for a given contact collapse into one cell, separated by commas. That’s fine if you have three tags. It’s a disaster if you’ve been tagging behavior for two years.

    Most platforms expect tags as separate boolean columns (e.g., tag_buyer, tag_clicked_launch) or as a structured array. A comma-delimited string in one field rarely imports cleanly. You’ll need to split it manually or write a script.

    Worse: tag history disappears entirely. If someone was tagged “trial_user” in March and you removed it in June, the export only shows current state. That matters if your automations rely on timing—like sending a win-back email 90 days after a tag was removed.

    What to document: Export your full tag list separately (Audience → Manage contacts → Tags). Note which tags trigger automations, which are archival, and which represent states vs. actions. Screenshot your automation canvas if it’s complex.

    Segment logic doesn’t transfer

    Segments in Mailchimp are queries, not lists. A segment like “opened any email in the last 30 days AND has tag ‘premium’ AND joined before January 2026” is just a filter. When you export subscribers, you get a snapshot of who matched that query at export time—not the logic itself.

    If you’ve built segments for behavior-based targeting (e.g., engaged readers, cart abandoners, trial expirees), you’ll need to rebuild those rules manually in your new platform. Some platforms—like Beehiiv—have simpler segmentation tools. Others, like MailerLite, offer more flexibility but require you to map Mailchimp’s condition syntax to theirs.

    What to document: Go to Audience → Segments and export each segment definition as a screenshot or text file. Note the conditions, the subscriber count, and when you last used it. If a segment feeds an automation, flag that dependency.

    Automation subscriber state vanishes

    Mailchimp tracks where each subscriber sits in each automation: pending, completed, exited, paused. That state doesn’t export. If you’ve been running a five-email onboarding series and someone is on email three, your new platform has no idea. They’ll either get nothing or restart from email one.

    This is especially painful for evergreen sequences tied to signup date or product purchase. You can’t reconstruct who’s already received what unless you cross-reference campaign send logs—and those are buried in reporting, not in the subscriber export.

    What to document: Before migrating, go to Automations and note active workflows. For each one, export the workflow report showing how many people are in-progress. If possible, pause automations a week before migration so fewer people are mid-sequence. Consider sending a manual “reset” email post-migration to anyone who might have been interrupted.

    Custom field types sometimes downgrade

    Mailchimp supports text, number, date, dropdown, and address fields. Your export will contain the values, but not the field type. A date field becomes a string. A dropdown becomes plain text. A numeric rating becomes text unless you manually convert it.

    That matters if your new platform uses field types for segmentation or conditional content. MailerLite, for instance, lets you filter by “date is within the last 30 days”—but only if the field is recognized as a date type. If it imports as text, you lose that functionality until you re-type it and re-import.

    What to document: Go to Audience → Settings → Audience fields and merge tags. Screenshot the field list with types visible. When you import to your new platform, recreate fields with correct types before uploading the CSV. Map columns carefully during import.

    What you should do a week before migrating

    Don’t wait until export day to inventory your list. A week out, do this:

    • Pause any automations that would leave subscribers mid-sequence.
    • Export your full subscriber list, tag list, segment definitions, and custom field schema.
    • Download campaign reports for the last 90 days (opens, clicks, unsubscribes by campaign).
    • Document which integrations push data into Mailchimp (Shopify orders, Typeform signups, Stripe payments). You’ll need to reconnect those.
    • Check your sending domain’s DNS records. If you’ve been using Mailchimp’s dedicated sending domain, you’ll need to reconfigure DKIM and SPF for your new platform.

    If you’re moving to a platform like Beehiiv or MailerLite, both offer migration support—but “support” usually means they’ll import your CSV, not reconstruct your automations. The more you document upfront, the less you’ll have to rebuild from memory.

    One more thing: test with a small list first

    Before importing your full list, create a test audience in your new platform with 50–100 subscribers. Import that subset, rebuild one automation, and send a test campaign. Check that tags imported correctly, custom fields retained their types, and segments return expected counts. If something broke, fix it before migrating everyone.

    Most platforms let you delete and re-import without penalty during trial periods. Use that window.

    Want more tool migration guides? Reply with the platform you’re switching to—we’ll cover the gotchas specific to that move.

    Heads up — some links in this article are affiliate links. If you sign up through them, we may earn a small commission at no extra cost to you. We only recommend tools we use ourselves.