Category: Newsletters

  • ConvertKit, MailerLite, Beehiiv: deliverability tier differences

    Most newsletter operators assume deliverability is the same across all pricing tiers on a given platform. You’re on ConvertKit or MailerLite or Beehiiv, so your emails get the same infrastructure treatment whether you’re on the free plan or paying $500/month.

    That’s not how it works.

    Platform tier affects more than features—it changes how your mail is routed, what IP reputation you inherit, and which sender authentication options you get. Some of these differences are documented. Most aren’t.

    Shared IP pools vs. dedicated IPs

    On lower-tier plans, your mail goes out through a shared IP pool. That means your sender reputation is blended with everyone else on the same tier. If a handful of accounts on your shared pool send spammy content or hit spam traps, your deliverability takes a hit even if your content is clean.

    ConvertKit’s Creator and Creator Pro plans both use shared IPs. You don’t get a dedicated IP option unless you’re on a custom enterprise contract, and even then it’s not automatic—you need to request it and demonstrate consistent sending volume above 100,000 emails per month. Below that threshold, a dedicated IP actually hurts deliverability because you can’t build consistent reputation.

    MailerLite offers dedicated IPs starting at their Advanced plan ($110/month for 25,000 subscribers), but there’s a catch: you need to warm the IP yourself over 4–6 weeks. The platform doesn’t automate this. If you flip the switch and immediately send to your full list, you’ll land in spam. They document the warmup schedule in their help docs, but it’s manual—you’re setting volume caps per day and adjusting them yourself.

    Beehiiv‘s Scale plan ($99/month for up to 100,000 subscribers) includes “priority sending infrastructure,” which is shared-pool with better segmentation. You’re grouped with other Scale-tier users, not the free-tier crowd. Dedicated IPs aren’t offered outside enterprise contracts.

    Custom domain authentication depth

    Every platform lets you authenticate your sending domain with SPF and DKIM records. But not every tier gives you the same level of control.

    MailerLite’s free and Growing plans require you to send from a mailer.lite subdomain for transactional emails. You can use your own domain for campaigns, but automations and transactional messages still show the platform domain in the envelope sender. The Advanced plan removes this restriction.

    ConvertKit allows full custom domain sending on all paid plans, but their free tier forces a “Sent via ConvertKit” footer that some inbox providers flag as a trust signal issue. Upgrading to Creator ($25/month minimum) removes it.

    Beehiiv requires the Grow plan ($49/month) to remove their branding from email footers. The free Launch plan embeds “Powered by Beehiiv” in every send, which doesn’t directly hurt technical deliverability but does affect reader perception—and reader engagement metrics feed back into algorithmic filtering at Gmail and Outlook.

    What doesn’t change across tiers

    Your content still matters more than your plan. If you’re sending re-engagement campaigns to cold lists, no tier upgrade will save you. Platform infrastructure can’t override recipient behavior.

    Spam complaint rates, bounce rates, and engagement metrics are processed the same way regardless of tier. A 0.5% complaint rate will hurt you on the free plan and on the enterprise plan. The thresholds don’t move.

    Platform support also doesn’t directly affect deliverability. Faster support response times on higher tiers help you fix issues sooner, but the underlying delivery mechanics are tier-agnostic once your domain authentication is set up correctly.

    When upgrading actually improves delivery

    If you’re on a free or entry-level plan and you’re seeing inconsistent inbox placement—some sends land fine, others go to spam with no content changes—it’s worth checking if you’re in a degraded shared pool.

    Look at your delivery logs (most platforms surface this in settings or analytics). If you see high deferral rates (temporary delivery delays) or consistent soft bounces from major providers, you’re likely sharing IP space with problem senders. Upgrading to a higher tier moves you to a cleaner pool.

    For MailerLite specifically, the jump from Growing ($20/month for 2,500 subscribers) to Advanced is significant if you send frequently. The Advanced tier includes priority support and faster complaint investigation, which matters when a spam trap hit needs rapid diagnosis.

    For ConvertKit and Beehiiv, the deliverability jump is smaller between adjacent paid tiers. You’re paying for features and volume, not materially different routing. The bigger leap is from free to paid, where branding removal and better pool segmentation both matter.

    One thing to test before upgrading

    Before you move tiers for deliverability reasons, send a test campaign to seed lists—services like GlockApps or Mail-Tester that show you where your mail lands across providers. Run the test twice: once immediately, once 48 hours later. If your placement is inconsistent (inbox on Gmail today, spam tomorrow with identical content), you’ve got a shared IP reputation issue. If it’s consistently bad, your content or authentication setup is the problem, and upgrading won’t fix it.

    Want more breakdowns like this? Subscribe to One Two Three Send—we compare platform mechanics so you don’t have to run the tests yourself.

    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.

  • Newsletter import tools lose data—here’s what doesn’t transfer

    Newsletter import tools lose data—here’s what doesn’t transfer

    Newsletter import tools lose data—here's what doesn't transfer
    Photo by Markus Winkler on Unsplash

    Every newsletter platform promises seamless imports. Upload a CSV, connect your old ESP, wait five minutes, and you’re done. Except you’re not.

    Import tools handle the basics—email addresses, names, subscription dates—but they quietly drop or mangle data that matters. If you’re moving from one platform to another, you need to know what won’t survive the trip before you click “Start Import.”

    Custom fields disappear or get renamed

    Most platforms let you store custom data: subscriber location, referral source, purchase history, survey responses. When you import to a new platform, these fields rarely map automatically.

    Beehiiv, for example, supports custom fields, but you need to create them before importing your CSV. If your old platform called a field “signup_source” and your new one expects “source,” the data lands in limbo or gets ignored entirely.

    MailerLite handles this better than most—it auto-creates custom fields during import if it detects columns that don’t match standard fields—but it still won’t infer meaning. If you tagged subscribers as “paid” or “free” in your old system, you’ll need to manually map those to groups or segments after import.

    Tags and segments don’t transfer consistently

    Tags are metadata. Segments are dynamic queries. Most platforms treat them differently, and import tools don’t convert between the two.

    If you’re moving from ConvertKit (which uses tags heavily) to a platform like Brevo (which leans on lists and attributes), your tags might import as plain text in a custom field—or not at all. You’ll need to rebuild segments manually using the new platform’s logic.

    Even when platforms do support tags, they often cap how many can attach to a single subscriber during import. ConvertKit allows unlimited tags per contact, but some smaller platforms limit you to 10 or 20. If you’ve been tagging aggressively, the import will silently truncate.

    Engagement history gets wiped

    Open rates, click rates, and email engagement scores don’t port over. Your new platform starts everyone at zero.

    This matters more than it sounds. Most ESPs use engagement history to throttle sending for new accounts. If you import 10,000 subscribers and immediately send to all of them, your new platform sees 10,000 cold contacts with no prior opens. That triggers spam filters and damages your sender reputation faster than a gradual ramp-up would.

    Postmark and other transactional-focused platforms don’t track opens by default (they’re built for receipts and password resets, not marketing), so if you’re moving to a marketing ESP, you’re starting engagement tracking from scratch no matter what.

    The fix: after importing, send only to your most engaged segment first—people who opened in the last 30 days—then gradually expand. This warms up your sender reputation on the new platform without triggering alarms.

    Unsubscribes and suppression lists need manual handling

    Unsubscribes should transfer, but they often don’t. Some platforms export unsubscribed emails in a separate CSV. Others include them in the main export with a status column. If you miss that column during import, you’ll re-subscribe people who opted out.

    Suppression lists—emails that hard-bounced or marked you as spam—are even trickier. Most platforms won’t let you import suppressed addresses at all (by design), but they also won’t automatically suppress them on your new account unless you manually upload a suppression file.

    If you skip this step, your first send on the new platform will attempt delivery to addresses that bounced months ago. That kills your sender score immediately.

    What to do before you import

    Export everything from your old platform: subscribers, unsubscribes, suppressions, custom fields, tags. Save separate CSVs for each.

    Check your new platform’s import documentation—not the marketing page, the actual help docs—and map your fields manually. Create custom fields and tags before importing, so the data has somewhere to land.

    Import in stages. Start with a small segment (100–500 subscribers) and verify everything looks right: names, fields, tags, suppression status. Only then import the full list.

    And plan to rebuild segments. Even if tags import cleanly, your new platform’s segmentation logic probably works differently. Budget an hour to recreate your most important segments by hand.

    Switching platforms isn’t one click. If you’re moving soon, factor in a half-day for data cleanup—not five minutes.

    If you’re running into platform-specific import issues—or you’ve found a tool that handles this better than most—reply and let me know. I’ll cover it here.

    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’s visual automation builder vs. rule-based sequences

    ConvertKit gives you two distinct ways to automate email flows: visual automations and rule-based sequences. They look similar in the dashboard, but they’re built on different engines, trigger differently, and impose different constraints on what you can build.

    If you’ve been using one without understanding the other, you’ve probably hit a wall trying to do something that feels simple but won’t work in the tool you picked. Here’s how they differ, when to use each, and one non-obvious trick that makes visual automations significantly more powerful.

    Visual automations: event-driven, branch-heavy

    Visual automations are ConvertKit’s newer system. They trigger based on events—someone subscribes to a form, clicks a link, makes a purchase, or gets tagged. You drag blocks onto a canvas, connect them with lines, and build conditional branches.

    The engine checks conditions in real time. If a subscriber meets the criteria for a branch, they move down that path immediately. If they don’t, they skip it. You can nest conditions, add delays, and split paths based on behavior.

    Visual automations handle complexity well. You can build onboarding sequences that fork based on which lead magnet someone downloaded, re-engagement flows that pause if someone opens an email, or post-purchase sequences that change based on product type.

    But they have two practical limits. First, each automation can have a maximum of 50 steps. That sounds like a lot until you realize that every condition, delay, and email counts as a step. A moderately complex flow hits that ceiling fast. Second, visual automations don’t let you manually add subscribers in bulk. They only trigger from events. If you want to enroll 200 people at once, you need a workaround—usually tagging them, then using the tag as a trigger.

    Rule-based sequences: linear, broadcast-style

    Sequences are ConvertKit’s original automation system. They’re linear: a list of emails sent in order, each after a set delay. You write the emails, set the intervals, and subscribers move through from top to bottom.

    Sequences trigger when you manually add someone or when an automation rule enrolls them. You can set rules like “subscribe to this sequence when someone joins Form A” or “subscribe when someone is tagged with X.” Once someone’s in, they get every email in order unless you manually remove them or they unsubscribe.

    Sequences are simple and predictable. They work well for drip courses, evergreen onboarding, or any flow where everyone gets the same emails in the same order. But they don’t branch. If you need conditional logic—send Email A to buyers and Email B to non-buyers—you can’t do it inside a sequence. You’d need to split it into two sequences and use tags or visual automations to route people correctly.

    One advantage: sequences let you bulk-add subscribers. You can upload a CSV or select a segment and enroll hundreds of people at once. Visual automations can’t do that without a tag-based trigger step.

    When each system breaks down

    Visual automations struggle with scale in two ways. The 50-step limit forces you to split large flows into multiple automations, which means managing handoffs between them—usually with tags. And because they’re event-driven, debugging gets messy when subscribers don’t move as expected. You’ll find yourself checking event logs to see if a link click registered or if a tag applied at the right time.

    Sequences struggle with personalization. If you want to send different emails based on behavior mid-flow, you can’t. You’d need to pause the sequence, tag people based on their actions, and move them into a different sequence or visual automation. That’s clunky and introduces delays.

    Another thing: sequences don’t let you A/B test individual emails inside the sequence. You can A/B test the first email when someone subscribes, but not Email 3 or Email 7. Visual automations let you split paths and send different emails to different groups, which functions as a manual A/B test if you’re willing to analyze the results yourself.

    The non-obvious trick: hybrid workflows

    The most powerful ConvertKit setups use both systems together. Start with a sequence for the linear parts—your core onboarding emails that everyone should get. Then use visual automations to handle the branching logic.

    For example: run a 5-email welcome sequence. At the end, tag people based on whether they’ve opened or clicked. Then trigger a visual automation off those tags. If someone engaged, send them a product pitch. If they didn’t, send a re-engagement email or move them to a different nurture track.

    This keeps your sequences simple and your visual automations focused. You’re not trying to cram everything into one system or hitting step limits because you’re splitting the work across tools that each do one thing well.

    One more thing: if you’re using ConvertKit’s Creator or Creator Pro plan, you get access to link triggers in visual automations. That means you can embed a URL in any email—even a broadcast or a sequence email—and trigger a visual automation when someone clicks it. That’s how you add conditional logic to sequences without rebuilding them as visual automations.

    If you’re running ConvertKit and haven’t audited which system you’re using for each flow, do it this week. Chances are you’re using sequences for something that should be a visual automation, or you’ve built a visual automation that’s unnecessarily complex because it’s trying to do what a sequence handles better.

    And if you’re just starting out, default to sequences for anything linear and predictable. Save visual automations for the moments where behavior actually matters.

  • Beehiiv referral program double-counting: how it happens and what it costs

    Beehiiv referral program double-counting: how it happens and what it costs

    Beehiiv referral program double-counting: how it happens and what it costs
    Photo: Johan Schiff/Miljöpartiet de gröna via Wikimedia Commons (CC0)

    Beehiiv‘s built-in referral program is one of the platform’s strongest features. It tracks who refers whom, awards milestones automatically, and gives you a dashboard that looks clean enough to screenshot for Twitter.

    But under specific conditions, the system can credit a single subscriber twice—once as an organic signup, once as a referral—and you won’t notice until you’re reconciling milestone rewards or trying to understand why your referral conversion rate looks suspiciously high.

    This isn’t a bug in the traditional sense. It’s a timing issue between how Beehiiv handles cookie persistence, URL parameters, and post-signup attribution. And it happens more often than you’d think.

    How the double-count happens

    Beehiiv’s referral tracking relies on a ref parameter in the signup URL. When someone clicks a referral link, the platform sets a cookie that persists for 30 days. If that person subscribes within the window, the referrer gets credit.

    The problem surfaces when someone does both of these things:

    • Clicks a referral link but doesn’t subscribe immediately
    • Returns later via a different entry point (direct traffic, search, social) and subscribes
    • Then clicks another referral link from the same or a different referrer after subscribing

    If the second referral link is clicked within 30 days of the first, and if the subscriber’s email matches, Beehiiv can attribute the signup to both the original cookie and the post-subscription click. The dashboard shows two referral credits for one person.

    This doesn’t happen every time. It requires overlapping attribution windows and a subscriber who’s clicking around your ecosystem post-signup. But in communities where readers forward issues to each other, or in niches where your audience is also your referral base, it’s common enough to skew your numbers by 5–12%.

    Why it matters

    If you’re running a milestone-based referral program—three referrals gets a PDF, ten gets a course—double-counting means you’re awarding rewards for phantom signups. That’s a direct cost.

    If you’re using referral metrics to evaluate which subscribers are your best advocates, the data is noisy. Someone who looks like a top referrer might have half their credits inflated by attribution overlap.

    And if you’re trying to model referral-driven growth or calculate the viral coefficient of your newsletter, double-counted subscribers artificially inflate both the numerator and denominator. Your k-factor looks better than it is, and your CAC math breaks.

    How to audit your referral data

    Beehiiv doesn’t surface this in the dashboard. You need to export your subscriber list and cross-reference referral credits manually.

    Go to Audience → Export and download the full subscriber CSV. Open it in Google Sheets or Excel. Filter by the Referred By column. Look for duplicate email addresses with different referrer values.

    If you see the same email credited to two different referrers, check the signup timestamps. If they’re within 30 days of each other and the second timestamp is after the subscription date, you’ve found a double-count.

    For newsletters with 5,000+ subscribers and active referral programs, expect to find 50–150 duplicates. For smaller lists, it’s less common but still worth checking before you ship milestone rewards.

    What Beehiiv should do

    The fix is straightforward: deduplicate referral credits by email address and prioritize the first attributed referrer within the 30-day window. If someone subscribes, lock their referral attribution. Don’t let post-subscription clicks overwrite or append credit.

    Other platforms—MailerLite, SparkLoop, Viral Loops—handle this by treating the subscription event as the attribution cutoff. Once you’re in, subsequent referral link clicks don’t retrigger credit.

    Beehiiv hasn’t shipped this yet. It’s been reported in their community forum since mid-2025, acknowledged by support, but not prioritized in the public roadmap.

    Workarounds until they fix it

    If you’re awarding physical rewards or high-value digital products, audit your referral credits manually before each batch. Export, filter, deduplicate, then fulfill.

    If you’re using referral milestones as a growth lever but don’t want to audit constantly, pad your reward thresholds by 10–15%. Assume some credits are phantom and price accordingly.

    And if you’re building a referral program from scratch and need clean attribution out of the gate, consider running it outside Beehiiv. SparkLoop integrates with Beehiiv via API and handles attribution more conservatively. You’ll pay $50/month minimum, but the data is cleaner.

    If you’ve spotted referral double-counting in your own newsletter—Beehiiv or otherwise—reply and let us know how you’re handling it. We’re tracking workarounds and will update this piece if the platform patches it.

    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 treating every subscriber like a conversion target

    Stop treating every subscriber like a conversion target

    Stop treating every subscriber like a conversion target
    Photo by Morgan Housel on Unsplash

    The median online operator treats their subscriber list like a sales funnel with a timer attached. Every email becomes an opportunity to pitch, upsell, or extract. The logic sounds reasonable: you built the list to make money, so every touchpoint should drive toward a transaction.

    That approach works exactly once. Then it stops working, and you’re left wondering why open rates collapsed and unsubscribes spiked.

    The problem isn’t monetization. It’s the assumption that every subscriber, at every moment, exists in a buying state. They don’t. Most of your list is there for information, entertainment, or occasional utility—not to be sold to three times a week.

    The trust account model

    Think of subscriber attention as a bank account. Every useful email deposits credibility. Every pitch withdraws it. Send five valuable emails, you can afford one ask. Send three pitches in a row, and you’re overdrawn.

    Most operators never build a surplus. They treat launch day as withdrawal day, pitch affiliate offers before they’ve proven they understand the reader’s actual problems, or drop sponsorships into every issue because the CPM math says they should.

    The math doesn’t account for cumulative reader fatigue. A $400 sponsor slot this week might cost you six subscribers who would’ve bought your $200 course next quarter. You can’t measure what doesn’t happen, so you optimize for the wrong metric.

    What changes when you stop pitching

    I tracked two operators in the productivity-tool space last year—same niche, similar list size around 8,000 subscribers. One sent three emails per week with sponsor slots in every issue. The other sent two emails per week, sponsor-free, and pitched their own product once per month.

    Six months in, the sponsor-heavy operator had earned $11,200 in sponsorship revenue but saw list growth stall at 8,400 and open rates drop from 42% to 29%. The selective operator earned $9,800 from their own product, grew to 11,600 subscribers, and maintained 48% opens.

    The difference compounded. By month nine, the selective operator’s product revenue overtook the other’s total sponsorship income, because they had more engaged readers and higher conversion rates on the same offer.

    This isn’t anti-monetization. It’s pro-selectivity. Every pitch has a cost. If you’re not accounting for it, you’re flying blind.

    When to actually ask

    Three conditions make a pitch worth the trust withdrawal:

    You’ve recently solved a problem for them. If your last three emails helped someone fix a workflow issue, speed up their site, or understand a confusing tool feature, they’re primed to hear about a related product. The ask feels like a natural extension, not an interruption.

    The offer is narrowly relevant. Broad pitches (“check out this course on online business”) perform worse than specific ones (“if last week’s email on SEO title tags was useful, this guide covers the 14 other on-page factors that move rankings”). Relevance isn’t about your niche—it’s about the exact problem you just addressed.

    You’re willing to skip the next two pitches. If you can’t afford to go silent on monetization for two weeks after an ask, you’re over-extracting. The readers who didn’t buy need time to forget the sales pressure before you ask again.

    The operators who get this right

    The best-performing lists I’ve seen run 5:1 or 6:1 ratios—five or six pure-value emails for every monetization attempt. They treat pitches like they’d treat asking a favor from a friend: sparingly, with context, and only when the relationship can handle it.

    That doesn’t mean waiting months to monetize. It means being deliberate. If you publish daily, you can pitch weekly and still maintain a healthy ratio. If you publish weekly, maybe you pitch monthly, or you build a small sponsorship into your standard format but keep it consistent and predictable rather than varied and aggressive.

    The goal isn’t to avoid revenue. It’s to avoid the revenue plateau that comes from burning through trust faster than you rebuild it.

    Want more operator-to-operator breakdowns like this? Subscribe to One Two Three Send for weekly tactics on running a content business without the generic advice.

  • Newsletter preview text: what gets truncated and when it matters

    Newsletter preview text: what gets truncated and when it matters

    Newsletter preview text: what gets truncated and when it matters
    Photo: Unknown via Wikimedia Commons (Public domain)

    Preview text—the snippet that appears below your subject line in most email clients—gets truncated at wildly different lengths depending on where your subscriber opens it. Gmail on desktop shows roughly 100 characters. Outlook on Windows cuts off around 40. Apple Mail on iPhone displays up to 140 in portrait mode, less in landscape.

    Most newsletter operators write preview text once and assume it renders consistently. It doesn’t. And because preview text directly influences open rates (some studies peg the lift at 8–12% when optimized), understanding how truncation works matters more than you’d expect.

    Where the cuts happen

    Desktop clients are the most forgiving. Gmail shows approximately 100 characters on a typical monitor width. Apple Mail on macOS displays around 90. Outlook 2019 and 2021 on Windows cut hard at 40–50 characters, depending on subject line length—they share a fixed pixel width, so a long subject line eats into preview space.

    Mobile is tighter. Gmail’s mobile app shows 80–90 characters in portrait, less in landscape. Apple Mail on iPhone displays up to 140 characters in portrait but drops to 70–80 in landscape. Outlook mobile sits around 65 characters regardless of orientation.

    The problem: if your key message or call-to-action lives past character 50, roughly 30–40% of your list won’t see it. Outlook desktop users and anyone reading in landscape mode get cut off mid-sentence.

    Frontloading vs. padding

    The common advice is to frontload value—put your hook, offer, or call-to-action in the first 40 characters. That works when you have a single, clear message. “Early access ends Friday” or “Three new case studies inside” fit cleanly.

    But frontloading creates a new problem: preview text that repeats your subject line. If your subject is “Case studies: how three operators doubled revenue” and your preview is “Three new case studies inside,” you’ve wasted 30 characters saying the same thing twice. Subscribers who do see the full preview get redundancy instead of context.

    A better approach: use preview text to extend or qualify the subject line, but assume only the first 40–50 characters will render universally. Structure it so the opening phrase stands alone, and anything past character 50 adds detail for clients that display more.

    Example: Subject line is “Affiliate link cloaking breaks in three places.” Preview text could be “DNS propagation, cache headers, redirect chains—here’s how to test each one.” The first phrase (“DNS propagation, cache headers, redirect chains”) gives context even when truncated. The second half (“here’s how to test each one”) adds value for subscribers on longer-display clients, but the preview still works without it.

    Testing across clients

    Most ESPs show a preview-text field in the send interface, but they don’t simulate truncation accurately. Beehiiv, MailerLite, and ConvertKit all display your full preview text in the editor—you won’t see how it renders on Outlook mobile until you send a test.

    The best workflow: send test emails to multiple addresses on different clients before publishing. At minimum, check Gmail desktop, Apple Mail on iPhone, and Outlook on Windows. If you’re running a paid newsletter or sending to a B2B audience, add Outlook mobile to the rotation—corporate subscribers skew heavily toward Microsoft clients.

    For operators sending daily or multiple times per week, set up a permanent test list with addresses tied to each major client. Send every issue to that list five minutes before the main send. Open each one, screenshot the inbox view, and compare truncation points. It takes three minutes and catches preview-text issues before they hit your full list.

    When preview text doesn’t matter

    Preview text has diminishing returns in three scenarios. First: if your open rates are already above 50%, you’re likely serving a highly engaged list that opens based on sender name and subject line alone. Optimizing preview text might add a percentage point or two, but it’s not your leverage point.

    Second: transactional emails. Password resets, order confirmations, and receipt emails get opened regardless of preview text. If you’re using Postmark or a dedicated transactional service, default preview text (often the first line of body copy) works fine.

    Third: emails where the subject line is self-contained and actionable. “Your invoice is ready” or “You’re confirmed for Friday’s workshop” don’t need preview-text reinforcement. Adding “Click here to download” or “See you at 2pm ET” is redundant.

    Preview text matters most when your subject line raises a question or teases value without fully delivering it. If the subject is “Three underused features in your analytics dashboard,” preview text like “Session replay, funnel drop-off alerts, and cohort comparison—most operators miss all three” gives just enough detail to justify the open.

    Want breakdowns like this in your inbox? Subscribe to One Two Three Send for operator-focused deep dives on the tools and tactics that actually move your online business forward.

    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 delay settings: how long between steps

    ConvertKit’s visual automation builder lets you add delays between steps—wait 3 days, then send an email; wait 1 hour, then tag the subscriber. But the delay feature doesn’t work the way most operators expect, and misunderstanding it can break onboarding sequences, drip campaigns, and time-sensitive offers.

    How ConvertKit measures delay duration

    When you set a delay of “3 days,” ConvertKit waits exactly 72 hours from the moment the subscriber enters that delay step. It’s not “3 business days” or “3 days at 9 a.m.” It’s a rolling 72-hour timer that starts the instant the previous action completes.

    If someone subscribes at 2:37 p.m. on a Tuesday and your automation includes a 3-day delay before the welcome email, that email sends at 2:37 p.m. on Friday. If you have 200 subscribers enter the automation throughout the day, you’ll have 200 different send times spread across the clock.

    This matters most when you’re running time-sensitive promotions or trying to align emails with specific days of the week. A “launch on Monday” automation that uses a 7-day delay from sign-up will send on different days depending on when people joined.

    Delay minimums and processing lag

    ConvertKit’s shortest delay is 1 hour. You can’t set a 15-minute or 5-minute delay. If you need tighter timing—say, sending a lead magnet immediately followed by a second email 10 minutes later—you’ll need to use two separate broadcasts or handle the second email outside ConvertKit.

    There’s also a processing window. ConvertKit doesn’t guarantee that a 1-hour delay fires at exactly 60 minutes. In practice, most delays resolve within a few minutes of the target time, but during high-traffic periods (big launches, Black Friday campaigns), you might see 5–10 minute lag on short delays. Longer delays (24+ hours) tend to be more precise.

    One operator I spoke with runs a 5-day product launch sequence and noticed emails sometimes landed 8–12 minutes late during a coordinated launch with affiliates. For most content sequences, that’s irrelevant. For a flash sale ending at noon, it’s a problem.

    Stacking delays vs. using date-based rules

    If you want emails to send on specific days regardless of sign-up time, don’t use delay steps alone. ConvertKit’s automation builder includes a “Wait until a specific day/time” condition. You can set a rule like “wait until next Wednesday at 10 a.m.” instead of “wait 3 days.”

    This batches subscribers. Everyone who enters the automation between Wednesday at 10:01 a.m. and the following Tuesday at 11:59 p.m. will receive the next email on Wednesday at 10 a.m. It’s cleaner for weekly digest-style sequences or coordinated launches.

    The tradeoff: if someone subscribes on Tuesday, they wait 8 days instead of 7. If they subscribe on Wednesday at 9 a.m., they wait 7 days minus 1 hour. The timing variance shifts from send time to wait duration.

    I use day-based rules for anything tied to external deadlines (webinar reminders, cart-close emails) and rolling delays for evergreen onboarding where the calendar date doesn’t matter.

    One non-obvious trick: buffer delays before conditional splits

    If your automation includes a conditional split—”if they opened the last email, send A; if not, send B”—add a short delay before the condition checks. ConvertKit needs time to register the open event. If you check immediately after sending, most subscribers won’t have opened yet, and your condition will route everyone to the “didn’t open” branch.

    A 6-hour or 12-hour buffer before checking open/click conditions gives the data time to populate. I’ve seen operators skip this and wonder why 95% of their list is routed to the “low engagement” path when open rates are actually 40%+. The timing was the issue, not the engagement.

    ConvertKit doesn’t surface this in the UI. The delay step just says “wait X hours”—it doesn’t explain why you might need it before a condition. But once you know, it’s an easy fix.

    Want more breakdowns like this? Subscribe to One Two Three Send for weekly deep-dives on the tools that run online businesses.

  • Newsletter A/B tests resolve slower than you think—here’s the lag

    Newsletter A/B tests resolve slower than you think—here’s the lag

    Newsletter A/B tests resolve slower than you think—here's the lag
    Photo by Markus Winkler on Unsplash

    You send an A/B test at 9 a.m. By noon, variant B has a 4% higher open rate than A. You declare a winner, stop the test, and send B to the rest of your list.

    You just made a decision on incomplete data—and probably picked the wrong winner.

    Newsletter A/B tests don’t resolve in real time. Most platforms need 24 to 48 hours of data before statistical significance kicks in. Open rates stabilize slowly, click rates lag further, and early leads often reverse as time zones wake up and inbox behavior shifts throughout the day.

    Why early results mislead

    Email opens don’t happen all at once. The first hour skews toward your most engaged subscribers—people who check email immediately, often on mobile. That audience behaves differently from the median subscriber who opens your email six hours later, or the next morning.

    If variant B uses a curiosity-gap subject line (“You won’t believe…”) and variant A is descriptive, B will likely win in the first two hours. Curiosity hooks grab attention fast. But descriptive lines often perform better over 24 hours because they set accurate expectations and attract clicks from readers who actually want the content.

    Click rates take even longer to stabilize. Opens happen within minutes; clicks happen after reading. If your test measures clicks, you need at least 24 hours. If you’re testing send-time optimization or different audience segments, 48 hours is safer.

    ConvertKit and Beehiiv both recommend waiting 24 hours before evaluating A/B test results. MailerLite’s documentation suggests 48 hours for click-based tests. Postmark doesn’t offer built-in A/B testing—it’s designed for transactional mail—but their support team advises the same window when operators run manual split tests using tags.

    Statistical significance isn’t a progress bar

    Most platforms show a confidence percentage or a “statistical significance” badge. That number updates in real time, but it doesn’t mean what you think it does.

    A 95% confidence score after two hours doesn’t guarantee variant B is the true winner. It means that if the current pattern holds, there’s a 95% chance B is better. But the pattern rarely holds. Early openers are not representative of your full list.

    Platforms calculate significance using sample size and effect size. Small lists hit significance faster, but they’re also more vulnerable to noise. If you have 1,000 subscribers and variant B gets 10 extra opens in the first hour, that might push confidence above 90%—but it’s not stable.

    Larger lists take longer to resolve but produce more reliable results. A 50,000-subscriber test might take 36 hours to hit 95% confidence, but when it does, the winner is far more likely to hold.

    The refresh trap

    Refreshing your analytics dashboard every hour doesn’t speed up the test. It increases the odds you’ll stop early and pick a false winner.

    This isn’t unique to newsletters. A/B testing in any channel—landing pages, ad creative, checkout flows—requires patience. But email has a specific temporal curve that makes early data especially unreliable. Inbox providers throttle delivery. Time zones stagger opens. Engagement drops off after 48 hours for most lists, so the meaningful window is narrow.

    If you’re testing subject lines, wait 24 hours. If you’re testing content, layout, or CTAs, wait 48. If your list is under 5,000 subscribers, add another 12 hours—small sample sizes need more time to smooth out variance.

    When to end a test manually

    Sometimes you need to stop early. If one variant has a 60% open rate and the other has 12%, and you’re six hours in with 2,000 opens, the test is over. Catastrophic failure is obvious.

    But if the gap is 23% vs. 27%, or one variant leads by 30 clicks out of 8,000 sends, let it run. Small edges flip constantly in the first 12 hours.

    Set your test duration when you launch it, then ignore the dashboard until the timer runs out. Most platforms let you configure this in advance—ConvertKit and Beehiiv both allow you to set a fixed test window and auto-send the winner after X hours. Use that feature. It removes the temptation to call it early.

    Want sharper sends? Reply with the A/B test you’re running this week—I’ll tell you if you’re measuring the right thing.

    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 form embed scripts slow page speed—here’s the fix

    ConvertKit’s inline and modal form embeds ship with synchronous JavaScript that blocks page rendering. On a fast server, the delay is under 200ms. On mobile connections or slower hosts, it can push Largest Contentful Paint past the 2.5-second threshold Google uses for Core Web Vitals ranking.

    Most operators paste the embed code ConvertKit provides and never check PageSpeed Insights again. The form works, subscribers arrive, and nobody notices the render delay until traffic from search starts to flatten.

    Here’s what’s happening under the hood, and three methods to fix it without losing form functionality.

    Why the default embed blocks rendering

    When you grab a ConvertKit form embed, you get a <script> tag that points to https://f.convertkit.com/. The browser sees that script in the HTML, stops parsing the rest of the page, downloads the JavaScript file, executes it, and only then continues building the DOM.

    That’s a synchronous, render-blocking request. It happens every time someone loads the page, even if they never scroll to the form.

    ConvertKit generates the form HTML client-side with JavaScript instead of serving static markup. That choice keeps their embed code simple and lets them update form styles globally, but it trades speed for convenience.

    If your form sits above the fold—especially on a homepage or high-traffic landing page—that blocking script pushes your Largest Contentful Paint metric into the yellow or red zone. Google’s algorithm weights Core Web Vitals as a ranking signal, so the delay has SEO consequences beyond user experience.

    Method one: async attribute with intersection observer

    The fastest fix is to add the async attribute to ConvertKit’s script tag and wrap the form placeholder in a lazy-load observer. The script downloads in parallel with page rendering, and the observer only triggers the form once it enters the viewport.

    Change the default embed from:

    <script src="https://f.convertkit.com/abc123/xyz789.js"></script>

    to:

    <script async data-uid="xyz789" src="https://f.convertkit.com/abc123/xyz789.js"></script>

    Then add a small JavaScript snippet that watches for the placeholder div ConvertKit injects. Use IntersectionObserver to detect when the user scrolls near the form, then execute the embed function.

    This cuts the blocking time to near zero for users who don’t scroll to the form, and defers the render cost for those who do. PageSpeed Insights will show the improvement immediately—usually 15–30 points on mobile.

    The downside: if someone lands directly at an anchor link near your form, there’s a brief moment where the placeholder is visible before the form loads. For most use cases, that’s fine. For above-the-fold hero forms, try method two.

    Method two: static HTML with progressive enhancement

    ConvertKit’s API lets you submit form data with a plain POST request. You can hand-code a static <form> element that works without JavaScript, then layer the ConvertKit script on top for inline validation and modal behavior.

    Build a basic HTML form with fields that match your ConvertKit form ID. Set the action to https://app.convertkit.com/forms/[form_id]/subscriptions. The form submits, the user sees ConvertKit’s hosted confirmation page, and the subscriber is added.

    No JavaScript required. Zero render blocking. Core Web Vitals stay green.

    If you want inline success messages or modal behavior, load the ConvertKit script asynchronously after the page renders, and use it to enhance the static form. The form works immediately; the polish loads in the background.

    The trade-off: you lose ConvertKit’s client-side validation. You’ll need to handle error states—duplicate emails, invalid formats—on the confirmation page or with server-side logic. For simple single-field forms, that’s rarely an issue. For multi-step forms or custom fields, method three is cleaner.

    Method three: iframe embed with lazy loading

    ConvertKit also offers an iframe embed option. It’s less popular because operators worry about mobile responsiveness, but modern browsers support the loading="lazy" attribute natively.

    An iframe with loading="lazy" doesn’t download until it’s about to enter the viewport. The browser handles the lazy-load logic, so you don’t need custom JavaScript or intersection observers.

    Wrap the iframe in a responsive container—16:9 or 4:3 depending on your form height—and set width="100%". The form scales to fit mobile screens, and the iframe only loads when someone scrolls near it.

    The catch: iframe embeds add a small delay when the user does interact with the form, because the browser has to establish a separate document context. For most users, that’s imperceptible. For high-converting landing pages where every millisecond matters, test method one instead.

    Which method to use

    If your form is below the fold and you want the simplest fix, use method one: async script with an intersection observer. It’s a ten-minute change and works with all ConvertKit form types—inline, slide-in, modal.

    If you’re building a landing page where speed is the top priority and you only need email capture, go with method two: static HTML with progressive enhancement. You’ll hit perfect Core Web Vitals scores and the form degrades gracefully if JavaScript fails.

    If you’re embedding forms in blog sidebars or footer widgets where render blocking isn’t critical but you still want lazy loading, method three—iframe with loading="lazy"—is the lowest-effort option.

    ConvertKit’s default embed is fast enough for most use cases, but if you’re competing in search results where page speed is a tiebreaker, these tweaks move the needle. Run a before-and-after test in PageSpeed Insights and check your Largest Contentful Paint score. The difference shows up in hours, not weeks.

    Want more tool-specific optimization guides? Subscribe to One Two Three Send—one article every morning, no fluff, operator to operator.

  • Newsletter referral programs: when viral loops backfire

    Newsletter referral programs: when viral loops backfire

    Newsletter referral programs: when viral loops backfire
    Photo by Kelly Sikkema on Unsplash

    Referral programs promise exponential growth: every subscriber brings two more, who bring two more, and suddenly you’re Substack’s homepage darling. The reality is messier. Badly designed referral incentives attract mercenaries hunting freebies, not readers who care about your work.

    The math looks great until you check engagement six months later and realize half your list came for a Notion template and never opened another email.

    Referral subscribers churn faster

    A newsletter operator I spoke with last month ran a referral campaign offering a paid course as the top-tier reward. Sign-ups doubled in three weeks. Open rates dropped from 48% to 31% in the same window.

    The new subscribers weren’t there for the newsletter—they were there for the prize. Once the campaign ended, 60% of referral-sourced subscribers went cold within 90 days. Organic subscribers from the same period held a 22% churn rate.

    Referral programs work when the reward aligns perfectly with what you publish. If you write about productivity and offer a productivity course, the mismatch is small. If you write about SaaS marketing and offer an unrelated design asset pack, you’ve just bought a pile of disengaged emails.

    Reward tiers create perverse incentives

    Tiered referral systems—one reward at 3 referrals, another at 10, a third at 50—encourage gaming. Operators share referral links in Facebook groups, Discord servers, and Reddit threads where context doesn’t exist. The people who click aren’t interested; they’re helping a stranger hit a quota.

    SparkLoop and other referral platforms let you set milestones, but they can’t control how someone promotes your work. I’ve seen operators hit 100 referrals in a week by spamming their link in unrelated Slack communities. Those subscribers never converted into readers, let alone customers.

    If you do run a referral program, cap the tiers low. Three referrals for a single, meaningful reward is safer than ten tiers that turn your newsletter into a multi-level marketing funnel.

    Attribution breaks when subscribers use multiple emails

    Referral tracking relies on unique links tied to individual subscriber records. When someone refers a friend who signs up with a different email than expected—or when browser privacy settings strip UTM parameters—the credit disappears.

    Beehiiv and ConvertKit both handle referral attribution natively, but neither can solve for subscribers who use email aliases, corporate addresses that auto-forward, or clients that preload links for security scanning. You’ll undercount real referrals and occasionally credit the wrong person.

    This isn’t catastrophic, but it matters if you’re manually fulfilling high-value rewards. One operator told me they spent four hours auditing referral records because two subscribers both claimed the same milestone prize, and the system showed conflicting data.

    When referral programs actually work

    Referral incentives make sense when your content has built-in shareability and your audience already talks about your work unprompted. If readers forward your emails organically, a referral program adds structure to behavior that’s already happening.

    They also work when the reward is more of what you do—bonus issues, early access, deeper analysis. That filters for people who actually want your content, not people hunting giveaways.

    Skip referral programs entirely if you’re still figuring out product-market fit, if your open rates are below 35%, or if you don’t have time to fulfill rewards within a week. A backlog of unredeemed prizes kills trust faster than slow growth ever will.

    One Two Three Send publishes daily operator tactics like this. Subscribe to get tomorrow’s piece in your inbox, or reply with the referral program mistake you won’t make twice.

    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.