Category: Newsletters

  • Newsletter referral programs: when you pay more than you earn

    Newsletter referral programs: when you pay more than you earn

    Newsletter referral programs: when you pay more than you earn
    Photo by Christian Agbede on Unsplash

    Newsletter referral programs sound like free growth. A reader shares your newsletter, someone new subscribes, the referrer gets a reward, and you gain a subscriber at zero acquisition cost. Except the math rarely works that way.

    Most operators launch referral programs without calculating what each referred subscriber actually costs—in rewards, platform fees, fulfillment time, and opportunity cost. By the time you tally it up, you’re often paying more per subscriber than a simple paid ad would have cost, and you’ve added ongoing operational overhead that doesn’t scale.

    What referral rewards actually cost

    The common referral ladder looks like this: refer three friends, get a free sticker; refer ten, get a bonus post or template; refer fifty, get a one-on-one call or a course. The reward tiers feel modest when you write them, but each tier carries a real cost.

    Digital rewards—bonus posts, templates, courses—cost time. If you’re giving away a $50 course for ten referrals, and that course took you twenty hours to build, you’re amortizing that time across every reward you give. If fifty people hit the ten-referral tier, you’ve given away 500 referred subscribers in exchange for work you could have sold for $2,500. That’s $5 per referred subscriber in forgone revenue, before you factor in platform fees.

    Physical rewards—stickers, books, swag—cost money and logistics. A $3 sticker plus $1.50 domestic shipping is $4.50 per reward. If your referral threshold is three subscribers per sticker, that’s $1.50 per referred subscriber in direct cost. International shipping doubles or triples that.

    High-value rewards—calls, coaching, custom work—cost time that doesn’t scale. A thirty-minute call for fifty referrals means you’re giving fifty referred subscribers in exchange for half an hour. If your hourly consulting rate is $200, that’s $4 per referred subscriber. If ten people hit that tier, you’ve just committed five hours to calls instead of client work or content production.

    Platform fees and tracking overhead

    Most newsletter platforms charge for referral program features. Beehiiv includes referral tracking in paid plans starting at $49/month. SparkLoop, the most popular third-party referral tool, starts at $50/month for up to 5,000 subscribers. If you’re running a 2,000-subscriber newsletter and paying $50/month for referral infrastructure, that’s $600/year before a single referral converts.

    If your referral program generates 200 new subscribers in a year—a strong outcome for most newsletters under 5,000 subscribers—you’ve paid $3 per subscriber in platform fees alone. Add reward costs and you’re above $5 per subscriber, which is higher than Facebook or Twitter ad costs for most niches.

    Then there’s tracking overhead. Referral programs require you to monitor tiers, validate referrals, fulfill rewards, and respond to questions. That’s recurring operational work that doesn’t exist if you acquire subscribers through other channels.

    When referral programs actually work

    Referral programs make sense in three scenarios. First, when your product has network effects and referrals improve the experience for everyone—think community newsletters or local event lists where more subscribers mean more user-generated content or better event turnout.

    Second, when your audience is highly engaged and already sharing without incentives. If you’re seeing organic shares and word-of-mouth growth, a referral program can amplify behavior that’s already happening. But if nobody’s sharing organically, a referral program won’t create that behavior—it’ll just add cost to a channel that isn’t working.

    Third, when your reward costs are near zero and your LTV is high. If you’re selling a $500/year subscription product and your referral reward is access to a digital archive you’ve already built, the incremental cost per reward is negligible and the payback period is short.

    For most operators running free or low-cost newsletters, none of those conditions apply. You’re better off spending that $600/year on a lead magnet, a small ad budget, or guest post outreach.

    The alternative: direct reciprocity

    If you want referral-style growth without the overhead, focus on direct reciprocity instead of tiered rewards. When someone shares your newsletter, thank them publicly or privately. When someone sends you a great subscriber, write them a personal note or give them a shout-out in your next issue. When someone consistently promotes your work, offer them something valuable—but make it contextual and personal, not part of a points system.

    This approach doesn’t scale to thousands of referrers, but it doesn’t need to. Most newsletters see 80% of referrals come from fewer than 20 people. Build direct relationships with those people. Skip the automation, skip the platform fees, and skip the operational overhead.

    Referral programs aren’t inherently bad, but they’re not free growth. Before you launch one, calculate what each referred subscriber will actually cost you—in money, time, and opportunity cost. If the math doesn’t beat your other acquisition channels, don’t build the program. Build the relationship instead.

    What’s your experience with referral programs? Reply and let us know what worked—or what didn’t. And if you found this useful, subscribe to get future breakdowns delivered twice a 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.

  • ConvertKit broadcast scheduling: why UTC offset breaks send times

    ConvertKit’s broadcast scheduler lets you pick a send time in your local timezone. But the platform stores that time as a UTC offset—and it doesn’t automatically adjust for daylight saving changes. If you schedule a 9am send in March and your region observes daylight saving in April, your broadcast will go out at 8am or 10am instead.

    This isn’t a bug. It’s how the system handles timezone data. And if you’re running a daily or weekly broadcast, you won’t notice until your open rates drop or readers start asking why your send time shifted.

    How ConvertKit stores scheduled send times

    When you schedule a broadcast for 9:00am Eastern Time, ConvertKit doesn’t store “9am Eastern.” It converts that to a UTC offset—currently UTC-4 during daylight saving, UTC-5 during standard time—and locks in the absolute UTC timestamp.

    If you schedule in winter (UTC-5) for a March send, that 9am broadcast is stored as 2pm UTC. When daylight saving kicks in and your local clock springs forward, your region is now UTC-4—but the broadcast still fires at 2pm UTC, which is now 10am local time.

    The reverse happens in autumn. A broadcast scheduled during daylight saving will arrive an hour early once standard time resumes.

    This affects any operator in a region that observes daylight saving: most of the US and Canada, parts of Europe, Australia, and a handful of other countries. If your timezone doesn’t shift, you won’t hit this issue.

    When this actually breaks your workflow

    One-off broadcasts are fine. You schedule, you send, you move on. The problem surfaces with recurring sends or templates you duplicate week after week.

    If you run a Tuesday morning briefing and schedule it every Monday night for a 7am send, you’ll duplicate last week’s broadcast, update the content, and leave the time slot untouched. That works until the clocks change—then your 7am send becomes 6am or 8am, depending on direction.

    Engagement suffers. A 6am send might hit inboxes before your audience wakes up, pushing your email down the stack. An 8am send competes with the morning rush and office distractions. Either way, open rates drop, and you won’t know why unless you check the actual delivery timestamp in your sent folder.

    How to avoid the offset trap

    The simplest fix: manually verify your send time after every daylight saving transition. Mark your calendar for the second Sunday in March and the first Sunday in November (US dates), and check every scheduled or recurring broadcast. If the time shifted, update it.

    If you’re scheduling more than a week out, pick your send time on the day you’re actually sending—not in advance. That way, the UTC offset reflects the current timezone rules.

    For operators running daily sends, consider switching to a relative schedule instead of an absolute one. ConvertKit doesn’t natively support “send X hours after signup” for broadcasts, but you can replicate the behaviour with a sequence: create a one-email sequence, set the delay to zero, and trigger it with a segment or tag. That way, the send time is always relative to subscriber activity, not a fixed UTC timestamp.

    Another option: use a timezone that doesn’t observe daylight saving. If you schedule in UTC or Arizona time (which stays on Mountain Standard year-round), your send time never shifts. Your local reference changes, but the broadcast fires at a consistent absolute hour. This works if your audience is global or if you don’t care about hitting a specific local time—just a consistent daily slot.

    What other platforms do differently

    Some ESPs handle this better. MailerLite stores send times as a timezone identifier (like America/New_York) rather than a UTC offset, so the platform automatically adjusts for daylight saving. You schedule 9am Eastern, and it stays 9am Eastern year-round, regardless of offset changes.

    Others, like Mailchimp, let you pick a subscriber’s local timezone for sends—so a 9am broadcast goes out at 9am in each recipient’s region. That’s useful for global lists, but it spreads your send window across 24 hours, which complicates analytics and real-time engagement tracking.

    ConvertKit’s approach isn’t wrong—it’s just literal. The platform does exactly what you tell it: send at this UTC timestamp. If you want a different timestamp after the clocks change, you have to say so.

    If timezone handling matters to your workflow—especially if you’re running daily sends or operating across multiple regions—test your platform’s behaviour before committing. Schedule a broadcast six months out, note the UTC offset, and check again after a daylight saving transition. If the local time shifted, you’ll need a manual or automated workaround.

    Got a question about email tooling or workflow automation? Reply to this email—we cover reader questions every Sunday.

  • Klaviyo’s flow filters stack backwards—here’s what fires first

    Klaviyo’s flow filters stack backwards—here’s what fires first

    Klaviyo’s visual flow builder shows filters stacked top-to-bottom, but the platform evaluates them in reverse. If you’re wondering why subscribers who shouldn’t qualify keep entering flows—or why eligible contacts get blocked—the evaluation order is probably the issue.

    Most operators assume Klaviyo reads filters like a book: top to bottom, left to right. It doesn’t. The platform processes conditional splits and trigger filters from the bottom of the stack upward, which means the last filter you add is the first one Klaviyo checks.

    How filter evaluation actually works

    When you build a flow in Klavivy, you add trigger conditions and conditional splits by stacking filters in the visual editor. A typical abandoned-cart flow might include:

    • Trigger: Started Checkout
    • Filter 1: Cart value greater than $50
    • Filter 2: Has not placed an order in the last 7 days
    • Filter 3: Email address contains “@gmail.com” (for a test segment)

    You’d expect Klaviyo to check cart value first, then recency, then email domain. Instead, it evaluates Filter 3, then Filter 2, then Filter 1. If any condition fails, the contact exits the flow without triggering downstream checks.

    This matters most when you’re using expensive API lookups, custom property checks, or time-based windows. A filter that queries your inventory API should run last in your logic chain—not first—so you’re only making the call for contacts who’ve already cleared cheaper, faster filters.

    When reversed logic breaks flows

    Reverse evaluation causes three common failure modes:

    Premature exits. If you place a narrow, restrictive filter at the bottom of the stack (visually), Klaviyo checks it first. Contacts who would have qualified under your primary conditions get blocked before those conditions are ever evaluated. You’ll see low flow-entry counts and wonder why your segmentation isn’t working.

    Wasted API calls. If your bottom filter pings an external service or checks a slow custom property, every single contact hits that check—even those who would’ve been disqualified by simpler conditions higher in the stack. At scale, this burns through rate limits and slows flow execution.

    Confusing A/B test results. If you’re testing two versions of a flow and one includes a filter at the bottom that the other lacks, the two flows aren’t just different in content—they’re evaluating contacts in a different order. Your test measures filter-stack architecture, not messaging.

    How to stack filters correctly

    Build your filter stack in reverse priority. The condition you want Klaviyo to check first should sit at the bottom of the visual stack. The condition you want checked last goes at the top.

    For an abandoned-cart flow, the correct visual order (top to bottom) would be:

    • Cart value greater than $50
    • Has not placed an order in the last 7 days
    • Email address contains “@gmail.com”

    Klaviyo will evaluate the Gmail filter first (fast, local check), then recency (medium-speed property lookup), then cart value (which may involve a Shopify API call depending on your integration setup).

    If you’re using conditional splits mid-flow, the same rule applies. Klaviyo evaluates the bottom branch condition first. If you’re splitting on “opened email in last 3 days” versus “clicked link in last 3 days,” put the click condition at the bottom so engaged contacts get prioritized before the broader open check runs.

    One non-obvious trick: use trigger filters to pre-qualify

    Instead of stacking filters inside a flow, move your fastest, most restrictive conditions into the trigger itself. Klaviyo evaluates trigger filters before the flow even starts, which means contacts who don’t qualify never enter the flow queue. This keeps your flow analytics clean and reduces server load.

    For example, if you only want to target customers with lifetime value above $200, add that as a trigger filter rather than a conditional split two steps into the flow. You’ll see accurate entry counts, and you won’t waste sends or delay timers on contacts who were never going to qualify.

    Klaviyo’s documentation doesn’t foreground the reverse-evaluation behavior—most operators learn it by accident after a flow misfires. Once you know the pattern, you can design filter stacks that execute faster, cost less, and behave predictably.

    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.

  • ConvertKit custom fields bloat subscriber profiles—when to use tags instead

    ConvertKit gives you two ways to track information about subscribers: custom fields and tags. Most operators pick one by habit or intuition, then run into performance problems, automation failures, or segmentation nightmares six months later.

    The difference isn’t just semantic. Custom fields and tags work differently under the hood, cost differently at scale, and break in different ways when you push them too hard.

    What custom fields actually store

    Custom fields hold variable data—strings, numbers, dates—unique to each subscriber. Think first name, referral source, purchase count, or renewal date.

    ConvertKit stores these as key-value pairs in your subscriber record. You can reference them in emails with liquid syntax ({{ first_name }}), filter segments by their values, and update them via API or form submission.

    The gotcha: every custom field you create adds a column to every subscriber record, whether populated or not. An empty field still exists in the database. Add twenty fields and you’re carrying twenty columns per contact, even if nineteen are blank.

    This doesn’t break anything immediately. But it slows segment queries, complicates exports, and makes your data harder to audit. I’ve seen accounts with forty-plus custom fields where only six held useful information. The rest were legacy experiments or half-finished automations.

    What tags actually track

    Tags are binary flags. A subscriber either has a tag or doesn’t. You can’t store a value in a tag—just presence or absence.

    ConvertKit indexes tags separately from subscriber records. Adding a tag doesn’t expand the subscriber table. It creates a relationship record in a join table. That architecture scales better when you’re tracking dozens of attributes.

    Tags also surface better in the UI. You can see all applied tags at a glance in the subscriber list. Custom field values require opening each record or exporting a CSV. For quick visual checks—who’s in the beta cohort, who opted into coaching—tags win.

    The downside: tags can’t hold nuance. If you need to store when someone joined the beta or which tier they purchased, a tag won’t cut it. You’ll end up creating beta_joined_2026_01, beta_joined_2026_02, and so on—tag sprawl that’s worse than a single date field.

    When to use custom fields

    Reach for custom fields when you need to store or reference a specific value:

    • Personalization tokens in email copy (first name, company, city)
    • Numeric counters that increment (emails opened this month, courses completed)
    • Dates for time-based logic (trial start date, last purchase, renewal window)
    • External IDs for syncing with other tools (Stripe customer ID, WordPress user ID)

    Custom fields also make sense when you need to filter segments by ranges or partial matches. “Purchase count greater than 3” or “City contains ‘New’” requires field-based logic. Tags can’t do that.

    When to use tags

    Use tags for binary states, audience segments, and behavioral flags:

    • Lifecycle stages (subscriber, buyer, churned, reactivated)
    • Interest categories (AI tools, WordPress, monetization)
    • Engagement tiers (active, dormant, cold)
    • Cohort membership (joined Q1 2026, beta tester, workshop attendee)

    Tags scale better when you’re tracking many attributes that most subscribers won’t have. If only 8% of your list are buyers, a buyer tag is leaner than a is_buyer custom field sitting empty on 92% of records.

    Tags also play nicer with automation branching. ConvertKit’s visual automations let you split paths based on tag presence with a single click. Doing the same with custom field values requires more setup and is harder to debug when it breaks.

    The hidden cost of choosing wrong

    I’ve worked with a SaaS newsletter operator who used custom fields for everything—including audience interests. They had fields like interested_in_AI, interested_in_SEO, and interested_in_monetization, each storing “yes” or blank.

    Segmenting required filtering by six different field conditions. Automations couldn’t branch cleanly. Exports included twelve columns of “yes” and empty cells. Switching to tags cut segment load time from four seconds to under one and made the automation map readable again.

    Conversely, I’ve seen operators try to use tags for dates. They’d create trial_started_2026_06_15, then realize a week later they couldn’t query “trial started more than 7 days ago” without manually adding 365 tags. A single trial_start_date custom field solved it.

    One non-obvious tip

    You can combine both. Use a custom field to store the precise value and a tag to mark the category.

    Example: store last_purchase_date as a custom field (for time-based logic and reference), then apply a buyer tag (for quick filtering and automation branching). The field gives you precision; the tag gives you speed.

    This hybrid approach works especially well for high-cardinality data—attributes that can take many values but where you still want fast segment access. Referral source is another good candidate: store the exact UTM in a field, apply a referral_traffic tag.

    Before you create your next custom field or tag, ask: am I storing a value I need to reference, or am I marking a state I need to check? The answer tells you which to use.

    Got a ConvertKit setup question? Reply to this email—I read every one, and reader questions become future articles.

  • Beehiiv’s boost network: when paid discovery costs more than it delivers

    Beehiiv’s boost network: when paid discovery costs more than it delivers

    Beehiiv‘s Boost network lets you pay to place your newsletter in front of other publishers’ audiences. You set a cost-per-subscribe bid, the network distributes your sign-up form as a recommendation block in other newsletters, and you pay only when someone converts.

    It sounds clean: growth on demand, no creative work, pay-per-result pricing. But the unit economics break down faster than most solo operators expect, and the subscriber quality often doesn’t match what you’d get from a direct swap or organic channel.

    How Boost pricing actually works

    You bid per subscriber. Beehiiv suggests a minimum around $1.00 to $2.00 depending on your niche, but competitive categories—business, finance, tech—regularly see bids north of $3.50. The platform runs an auction: your bid competes against other newsletters targeting similar audiences, and higher bids get more placement.

    If you’re spending $3.00 per subscriber and converting 100 sign-ups, that’s $300. Compare that to a single well-placed guest post, a Reddit comment thread that goes viral, or a reciprocal mention in a newsletter with 5,000 engaged readers. Those channels cost time, not cash, and the subscribers tend to stick around longer because they arrived with context.

    Boost also takes a 20% platform fee on top of your bid when you’re the one receiving the promotion revenue. So if another publisher is willing to pay $2.00 per subscriber to reach your audience, you only net $1.60. That margin matters if you’re considering Boost as a two-sided marketplace—running campaigns and monetizing your own list simultaneously.

    Subscriber quality lags behind owned channels

    Boost subscribers convert at the point of least intent. They see a recommendation block, often at the bottom of someone else’s newsletter, and click through with minimal context about what you publish. Compare that to someone who found you via search, read three articles, then subscribed—or someone who saw you interviewed on a podcast and went looking for your sign-up page.

    The data backs this up. Operators I’ve spoken with report Boost subscribers opening 10–15 percentage points lower than their list average, and unsubscribe rates spike in the first three sends. You’re not buying an audience; you’re renting attention from people who were already reading something else.

    That doesn’t make Boost useless—it makes it a cold-traffic channel. If your welcome sequence is strong and your first three emails do the work of educating and filtering, you’ll retain some of those subscribers. But if you’re comparing cost-per-acquisition across channels, Boost often ranks as the most expensive per engaged subscriber, not just per sign-up.

    When Boost makes sense (and when it doesn’t)

    Boost works if you have a monetization model that converts cold traffic quickly—like a low-ticket digital product, an affiliate funnel, or a sponsored placement you’re testing. You can afford a $3.00 CPA if your average subscriber generates $8.00 in affiliate commissions in the first 30 days. The math breaks even, and you’re buying reach you couldn’t generate organically in the same timeframe.

    It also works as a diagnostic tool. Run a small Boost campaign with $100–$200, track open rates and unsubscribe behavior, and compare the cohort to your organic subscribers. If the gap is narrow, your welcome sequence is doing its job. If Boost subscribers churn at 40% in week one, you know the acquisition channel isn’t the only problem—your onboarding needs work.

    Where Boost fails: when you’re pre-revenue, when your content needs warm context to make sense, or when you’re trying to grow a tight community rather than a broadcast list. Paying $2.50 per subscriber to add 500 unengaged emails to your list doesn’t move your business forward. It inflates a vanity metric and increases your monthly platform costs if you’re on a plan that charges per contact.

    Compare Boost to organic cross-promotion first

    Before you allocate budget to Boost, exhaust direct swaps. Reach out to five newsletter operators in adjacent niches—not competitors, but publishers whose audience would genuinely benefit from your content—and propose a mutual recommendation. No money changes hands. You write a 50-word blurb about them, they write one about you, and you both send it to your lists.

    A single swap with a newsletter that has 3,000 engaged readers can net you 30–80 subscribers at zero cost, and those subscribers already trust the curator who recommended you. That’s a conversion rate and engagement quality Boost struggles to match, even at $4.00 per sign-up.

    If organic swaps aren’t yielding results, the problem is usually positioning, not distribution. Fix your one-sentence pitch, tighten your welcome email, and make sure your archive demonstrates consistent value. Then revisit paid channels.

    One thing to try this week: If you’re on Beehiiv and considering Boost, run a $100 test campaign and tag those subscribers in a separate segment. Compare their 30-day open rate and unsubscribe rate to your organic cohort from the same period. If the gap is wider than 20 percentage points, reallocate that budget to a guest post or a direct swap instead.

    Have a question about newsletter growth tactics or want to share your own Boost numbers? Hit reply—I read every response.

    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 measuring open rate—deliverability lives in the spam folder

    Stop measuring open rate—deliverability lives in the spam folder

    Most solo operators watch open rates like a hawk. A 40% open rate feels like success. A 25% rate triggers panic and a subject-line audit.

    But open rate measures engagement among people who received your email in their inbox. It tells you nothing about the readers who never saw it because Gmail, Outlook, or Apple Mail dumped it straight into spam or the Promotions tab.

    If 30% of your list never sees your email, a 40% open rate on the remaining 70% means your true reach is closer to 28%. You’re optimising the wrong number.

    What deliverability actually measures

    Deliverability isn’t whether your ESP successfully handed off the email to the recipient’s server. That’s the delivery rate, and it’s usually above 98% unless your domain is blacklisted.

    Deliverability is inbox placement—the percentage of delivered emails that land in the primary inbox, not spam, not Promotions, not the Updates tab.

    Your ESP’s dashboard won’t show this number by default. Most platforms report delivery rate and open rate, then stop. A 99% delivery rate and 35% open rate looks healthy until you discover that 40% of your delivered emails went straight to spam.

    How to check where your emails actually land

    The simplest method: seed lists. Create a free account on Gmail, Outlook, Yahoo, and Apple iCloud. Add those addresses to a hidden segment in your ESP. Send every broadcast or automation to that segment, then manually check each inbox and spam folder within an hour of sending.

    Log what you see:

    • Primary inbox
    • Promotions tab (Gmail)
    • Spam folder
    • Not delivered at all

    Do this for ten consecutive sends. If more than two land in spam or Promotions, you have a placement problem, not an engagement problem.

    For a more automated approach, use a tool like GlockApps, Mail-Tester, or Litmus Spam Testing. These services give you test addresses across dozens of providers and return placement reports within minutes. GlockApps starts at $49/month for 30 tests. Mail-Tester offers pay-as-you-go at $0.50 per test. Litmus Spam Testing is included in Litmus Email Analytics plans starting at $99/month.

    What breaks inbox placement (and what doesn’t)

    Common advice blames spammy subject lines or too many exclamation points. In practice, inbox placement breaks for infrastructure reasons first, content reasons second.

    Authentication failures. If your SPF, DKIM, or DMARC records are misconfigured or missing, ISPs treat your emails as unverified. Even a single failed authentication check can trigger spam filtering. Check your DNS records using MXToolbox or dmarcian. If you’re sending from a subdomain (e.g., news.yourdomain.com), make sure your DKIM selector matches and your SPF record includes your ESP’s sending IPs.

    Low engagement history. ISPs track how recipients interact with your domain over time. If your last ten emails had sub-20% open rates or high spam-complaint rates, future emails start in spam by default. This creates a vicious cycle: spam placement lowers engagement, which worsens future placement.

    Sudden volume spikes. Sending to 5,000 subscribers after months of sending to 500 looks like a compromised account. Ramp slowly. If you’re reactivating a cold list or migrating ESPs, warm your domain by sending to your most engaged segment first, then expand over two weeks.

    Shared IP reputation. If you’re on a shared sending IP (most ESPs below $100/month), your placement depends partly on other senders using the same IP. One spammer on your IP can hurt your placement. Platforms like Postmark and Mailgun isolate transactional senders onto separate IP pools with stricter quality controls. If you’re sending fewer than 50,000 emails per month, a shared IP on a quality ESP is usually fine—just avoid the cheapest bulk-email platforms.

    The non-obvious fix: prune faster

    Here’s the tactic most operators resist: remove unengaged subscribers before they hurt your sender reputation.

    If someone hasn’t opened an email in 90 days, they’re either not reading, using an email client that blocks tracking pixels, or your emails are landing in spam. Keeping them on the list lowers your engagement rate, which signals to ISPs that your content isn’t wanted.

    Set up a 90-day re-engagement automation: one plain-text email asking if they still want to hear from you, with a clear unsubscribe link. If they don’t click within seven days, remove them from your main list. Move them to a separate “cold” segment if you want to try again in six months, but stop sending regular broadcasts.

    This will drop your subscriber count. It will improve your open rate, click rate, and inbox placement. ISPs reward senders who mail engaged audiences.

    One metric to watch weekly

    If you track one number, make it your spam complaint rate—the percentage of recipients who mark your email as spam. Your ESP’s dashboard will show this, often buried under “Abuse Reports” or “Complaints.”

    Anything above 0.1% (one complaint per 1,000 emails) is a red flag. Above 0.3%, ISPs start throttling your delivery. Above 0.5%, you’re headed for blacklist territory.

    If your complaint rate spikes, stop sending and audit your signup flow. Are people actually opting in, or are you adding them without explicit consent? Is your unsubscribe link visible and one-click? Are you sending more frequently than you promised at signup?

    Most complaint spikes trace back to expectation mismatches, not content quality.

    Want to go deeper on email infrastructure and deliverability tactics? Reply to this email with your biggest placement headache—I’ll cover the most common issues in a future piece.

  • ConvertKit’s visual automation builder: when branches break your flow

    ConvertKit’s visual automation builder replaced the old “sequence + rule” system in 2019, and most solo operators treat it like a flowchart app: drag some boxes, draw some lines, hit publish. It works—until you nest a few conditional branches or try to merge two paths back into one step, and subscribers start falling through cracks you didn’t know existed.

    The builder feels intuitive because it mirrors how we sketch funnels on paper. But the canvas hides execution logic that doesn’t always match what the diagram suggests. Here’s what actually happens under the hood, when to use it, and one non-obvious trick that keeps automations from breaking when you scale them.

    How the builder actually executes branches

    ConvertKit’s automation engine evaluates conditions at the moment a subscriber reaches that step. If you branch on “has tag X,” the system checks tag state right then—not when they entered the automation, and not continuously. That’s fine for simple yes/no splits, but it creates two common failure modes.

    First: timing gaps in nested branches. If you add a five-day delay before a conditional check, and the subscriber gains or loses the relevant tag during that delay, the branch decision reflects the tag state on day five—not day zero. Most operators assume the branch locks in at entry. It doesn’t.

    Second: parallel branches don’t merge cleanly. The canvas lets you draw two separate paths that converge into a single “Send email” step. Visually, it looks like both paths feed into one action. In practice, ConvertKit treats each incoming connection as a separate trigger. If a subscriber qualifies for both branches simultaneously—say, they have two tags that each route them down a different path—they’ll hit that shared email step twice and receive duplicate sends. There’s no automatic deduplication at merge points.

    When to use the visual builder vs. segments and broadcasts

    The automation builder shines when you need time-based sequencing with simple branching—onboarding flows, drip courses, or post-purchase follow-ups where the next step depends on one or two clear conditions (opened email, clicked link, purchased product). It’s purpose-built for “if this, then wait X days, then do that” logic.

    It’s the wrong tool when you need complex multi-condition logic or frequent re-evaluation. If your segmentation involves “has tag A and tag B, but not tag C, and joined before date D,” you’re better off using ConvertKit’s segment builder and sending one-off broadcasts to that segment. Segments re-evaluate in real time; automations evaluate once per step. Trying to replicate segment logic inside an automation canvas leads to branching spaghetti that’s impossible to debug when a subscriber reports they didn’t get an email.

    The other time to avoid the builder: when you need to pause or edit a live flow without stopping new subscribers. ConvertKit doesn’t let you edit an active automation. You have to duplicate it, make changes, archive the old one, and redirect new subscribers to the new version. Anyone mid-flight in the old automation stays there until they complete it or you manually move them. For high-traffic funnels, that’s a versioning nightmare. A combination of tags, segments, and scheduled broadcasts gives you more control.

    The non-obvious trick: use events, not tags, for branch conditions

    Most operators branch on tags because tags are visible and easy to apply. But tags are state—they can be added, removed, or changed by other automations, manual bulk actions, or integrations. If two automations both manipulate the same tag, you’ve introduced race conditions you can’t see on the canvas.

    ConvertKit’s event triggers—”Purchased product,” “Completed form,” “Clicked link in email”—are immutable. Once an event fires, it stays in the subscriber’s history. Branching on events instead of tags eliminates the timing-gap problem: you’re checking “did this happen” rather than “does this tag currently exist.”

    Practical example: instead of branching on “has tag: clicked-link-in-welcome-email” (which you’d apply via a separate link-trigger automation), branch directly on the event “Clicked link in [specific email].” It’s one fewer moving part, and the condition can’t be accidentally overwritten by a bulk tag removal you run three months later.

    The trade-off: events are harder to manipulate manually. If you need to retroactively mark someone as having completed a step, you can add a tag by hand; you can’t fake an event. For most use cases, that’s a feature, not a bug—it forces you to model your automation around actual subscriber behavior rather than abstract state.

    What to check before you publish

    Before you activate any automation with more than two branch points, walk through it as if you’re a subscriber who qualifies for multiple paths simultaneously. ConvertKit’s preview mode only shows you one path at a time; it won’t surface the duplicate-send issue. Manually trace each route on paper or in a separate doc.

    Also check your delays. ConvertKit’s builder lets you stack delays inside branches, and the total wait time isn’t surfaced anywhere in the UI. I’ve seen onboarding automations where the “fast track” branch accidentally included 14 days of cumulative delays because each step added “wait 2 days” without the operator realizing they’d nested four of them. Subscribers stopped engaging because the follow-up came two weeks late.

    Finally, set up a test subscriber with a disposable email and run them through the full flow in real time—don’t just use preview mode. Create the edge-case conditions: apply conflicting tags, click links out of order, purchase mid-sequence. You’ll catch merge issues and timing gaps that don’t show up in the visual review.

    If you’re running ConvertKit automations and want more tools and breakdowns like this one, subscribe to One Two Three Send. We cover the features and gotchas that don’t make it into official docs—one concrete piece per week, no fluff.

  • Newsletter subscriber surveys: what to ask and what to skip

    You want to know what your subscribers care about. A survey feels like the obvious solution. But most operators write surveys that produce either useless vanity metrics or mountains of data they don’t have time to parse.

    The problem isn’t surveying itself—it’s asking the wrong questions, at the wrong time, in the wrong format. Here’s how to build a subscriber survey that gives you actionable editorial direction without burning goodwill or drowning in responses you can’t use.

    Ask about future content, not past issues

    The most common survey mistake is asking subscribers to rate or rank your previous newsletters. “Which issue did you like best?” or “How would you rate our content?” These questions feel safe, but they’re backward-looking and subjective.

    Instead, ask what they want to read next. Frame questions around problems they’re trying to solve or topics they’re actively researching. For example:

    • “What’s the biggest challenge you’re facing with [your niche topic] right now?”
    • “Which of these topics would help you most in the next 30 days?”
    • “What question do you wish someone would answer about [topic]?”

    You’re not polling for popularity—you’re mining for editorial gaps. The answers tell you what to write, not whether people liked what you already sent.

    Keep it to three questions, maybe four

    Survey fatigue is real. If your form scrolls, response rates drop. If it takes more than 90 seconds, you lose half your respondents before they finish.

    Limit yourself to three core questions. If you absolutely need a fourth, make it optional. Use multiple-choice wherever possible—open-text fields are harder to analyze at scale, and most subscribers won’t fill them out anyway.

    Here’s a template structure that works:

    • Question 1: Multiple-choice topic preference (4–6 options)
    • Question 2: Open-text pain point or challenge (optional)
    • Question 3: Demographic or context question (e.g., “How long have you been running your business?”)

    That’s it. You’ll get a higher completion rate and cleaner data.

    Segment your ask—don’t survey everyone at once

    Not all subscribers need to answer the same questions. If you’re running a newsletter with both beginners and experienced operators, surveying them together will muddy your results.

    Instead, segment your survey by behavior or tenure. For example:

    • New subscribers (joined in the last 30 days) get a short onboarding survey focused on their current goals.
    • Engaged readers (opened 8+ of the last 10 emails) get a deeper content-direction survey.
    • Inactive subscribers (haven’t opened in 60+ days) get a simple re-engagement question: “What would make this newsletter more useful to you?”

    Most email platforms—MailerLite, Beehiiv, ConvertKit—let you tag or segment by open rate or signup date. Use that data to send the right survey to the right group.

    Don’t survey more than twice a year

    Survey burnout is worse than survey silence. If you ask for feedback every quarter, subscribers start ignoring you. Once or twice a year is plenty—unless you’re pivoting your editorial strategy or launching a new product.

    When you do survey, close the loop. Send a follow-up email a week later summarizing what you heard and what you’re changing. It doesn’t have to be long—three bullet points and a sentence about what’s coming next. This reinforces that their input mattered and primes them to respond next time.

    One operator I know sends a yearly survey in January and a mid-year check-in in June. Both are three questions, both close with a “here’s what I heard” email. Her response rate hovers around 22%, well above the typical 10–15% for cold surveys.

    Skip the NPS question

    Net Promoter Score—”How likely are you to recommend this newsletter?”—is a corporate metric that doesn’t translate well to solo operators. It’s designed for companies with large customer bases and multi-touch attribution. For a newsletter, it’s noise.

    You don’t need a numerical score. You need to know what to write next and whether you’re solving the right problems. Save the NPS question for SaaS dashboards.

    Use survey data to build a content queue, not a strategy document

    Once responses come in, resist the urge to over-analyze. You’re not running a focus group—you’re filling your editorial calendar.

    Pull the top three topics or pain points mentioned. Schedule one article or issue for each in the next 30 days. If a question came up repeatedly in open-text responses, turn it into a Q&A or tutorial. That’s the loop: ask, write, ship.

    Survey data goes stale fast. If you wait two months to act on feedback, the problems your subscribers cared about in March might be irrelevant by May. Treat survey results like perishable inventory.

    Want more tactical breakdowns like this? Subscribe to One Two Three Send for weekly deep-dives on the tools, tactics, and trade-offs that matter for online operators.

    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 welcome sequences: when to automate and when to write live

    Newsletter welcome sequences: when to automate and when to write live

    Most newsletter operators set up a welcome sequence once and forget about it. The logic seems sound: new subscribers always need the same introduction, so why not automate it?

    But welcome sequences live in a strange place between evergreen content and live conversation. Get the format wrong, and you either sound robotic when you should be present, or you create unsustainable manual work when automation would serve you better.

    Here’s how to decide which approach fits your operation.

    When automation works

    Pre-written welcome sequences make sense when your content library is large enough that new subscribers need a map. If you’ve published 50+ issues, a three-email drip that surfaces your best work by category will outperform a single “thanks for subscribing” note.

    The same applies if you’re running a lead magnet funnel. Someone downloads a PDF, gets added to your list, and expects a specific follow-up. That’s a transactional flow, and transactional flows should run on rails.

    Beehiiv and MailerLite both handle this well. You can queue up to five emails, set delays between sends, and track open rates per step. Beehiiv‘s boost feature even lets you A/B test subject lines within the sequence, which matters if you’re optimizing for a paid conversion at the end.

    Automation also makes sense when you’re publishing infrequently. If you send once a month, a welcome sequence keeps new subscribers warm between issues. Without it, they forget why they signed up.

    When live writing wins

    If you’re publishing daily or multiple times per week, a static welcome sequence can feel like a time warp. A new subscriber joins on Tuesday, reads your live Wednesday issue, then gets a pre-written “welcome” email on Thursday that references content from two months ago. The cognitive dissonance kills momentum.

    In high-frequency operations, the better move is a single welcome email written fresh each week. You introduce yourself, link to the last three issues, and invite a reply. It takes five minutes, but it reads like you wrote it for them, because you did.

    This approach also works if your newsletter is personality-driven. Readers subscribe because they want to hear from you, not from a drip campaign you set up in 2024. A live welcome email—even a short one—reinforces that they’re joining a conversation, not a content library.

    The trade-off is time. If you’re adding 200 subscribers a week, writing individual welcomes isn’t realistic. But if you’re growing slowly and deliberately, the personal touch compounds. Reply rates on live welcome emails run 8–12% in my experience, compared to 2–3% for automated sequences. That’s not just a metric—it’s the start of a relationship.

    The hybrid approach

    Some operators split the difference: they automate the first email (instant, transactional, “here’s what you signed up for”) and manually send a second note 48 hours later that references the week’s topic or a recent reply thread.

    This works especially well if you’re running a paid newsletter. The first email confirms payment and sets expectations. The second email, written live, makes it clear that a human is on the other end. Postmark’s tagging system makes this easy to execute—you can trigger the first email via API and queue the second as a manual campaign to anyone who subscribed in the last two days.

    The key is intentionality. If you automate, make sure the sequence still reflects your current positioning. If you write live, make sure you’re not burning an hour per week on a task that could run itself.

    What to measure

    The best signal is reply rate. If fewer than 3% of new subscribers respond to your welcome message—automated or live—something’s off. Either the tone is too formal, the call-to-action is too vague, or you’re not asking a question worth answering.

    Open rate matters less than you think. A 60% open on a generic “Welcome to the list” email doesn’t mean much if no one clicks or replies. A 40% open on a live note that starts a conversation is worth more.

    Track unsubscribes within the first seven days, too. If more than 5% of new subscribers bail before they read a second issue, your welcome message is either overpromising or underdelivering. Tighten the gap.

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

    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.

  • Newsletters drain deliverability faster than they build trust

    Newsletters drain deliverability faster than they build trust

    Most newsletter operators believe that more touchpoints build more trust. Send twice a week instead of once. Add a Sunday bonus. Launch a daily tip series. The logic sounds reasonable: more contact equals more familiarity, and familiarity drives conversions.

    But that logic ignores the infrastructure layer underneath every newsletter: deliverability.

    The truth is that increasing send frequency without corresponding engagement gains doesn’t build trust—it destroys your sender reputation, tanks inbox placement, and turns your entire archive into spam fodder. You’re not building authority. You’re training inbox algorithms to ignore you.

    How send frequency damages sender reputation

    Email service providers track your sender reputation using a combination of signals: open rates, spam complaints, bounce rates, and engagement velocity. When you double your send frequency, you need to double your engaged audience to maintain the same reputation score.

    Here’s what actually happens: you send twice as often, but your open rate drops by 30–40% because subscriber attention is finite. Your most engaged readers might open both emails, but your median subscriber opens one or neither. Your overall engagement rate falls. ISPs interpret that drop as a signal that your content is less relevant, and they adjust inbox placement accordingly.

    The math is unforgiving. If you send once a week to 10,000 subscribers with a 40% open rate, that’s 4,000 engaged readers per send. Switch to twice a week with a 28% open rate (a realistic drop), and you’re down to 2,800 engaged readers per send—5,600 per week total. You’re sending twice as much for a 40% gain in absolute engagement, but your per-send reputation score is now 30% lower.

    Gmail and Outlook don’t care about your weekly totals. They care about per-campaign signals.

    The engagement cliff

    Once your sender reputation drops below a certain threshold, inbox placement collapses non-linearly. You don’t gradually slide from inbox to promotions tab. You fall off a cliff into spam folders, and recovery takes months of disciplined list hygiene and reduced sending.

    I’ve watched this happen to operators who went from weekly to daily sends without testing the transition. Within six weeks, their inbox placement rate dropped from 92% to under 60%. Their open rates fell further because fewer people saw the emails in the first place. The feedback loop is vicious: worse placement drives lower engagement, which drives worse placement.

    The operators who recovered did so by cutting send frequency in half, removing unengaged subscribers, and rebuilding slowly over 90 days. Some never fully recovered their original inbox rates.

    When frequency works—and when it doesn’t

    High send frequency works in exactly one scenario: when you have an audience that actively wants daily or near-daily content, and you can prove it with engagement data.

    If you’re running a news digest, a stock-tip service, or a highly segmented course drip, frequent sends can work—because your audience expects them and opens them. But even then, you need to monitor per-campaign open rates religiously and cut frequency the moment engagement drops.

    For the rest of us—commentary writers, niche educators, solo operators building authority in a specific domain—frequency is a tax on reputation. Your subscribers don’t need to hear from you three times a week. They need to hear from you when you have something worth saying, and they need to open the email when it arrives.

    One high-quality send per week with a 45% open rate will build more trust and deliver better long-term results than three mediocre sends per week with a 22% open rate. The total engaged-reader count might look similar in a spreadsheet, but the infrastructure consequences are not.

    What to do instead

    If you’re tempted to increase frequency, test it properly. Segment a portion of your list and send them the higher-cadence version for 30 days. Track per-campaign open rates, spam complaints, and unsubscribe rates. Compare those numbers to your control group.

    If engagement holds or improves, roll out the change slowly. If engagement drops even slightly, revert immediately. A 10% drop in per-send open rate today becomes a 40% drop in inbox placement six months from now.

    And if you’re already sending frequently and seeing declining engagement, the fix is simple but painful: send less. Cut your frequency in half, improve your content quality, and give your sender reputation time to recover. It’s not exciting, but it works.

    Want to dig into deliverability mechanics and list-health strategies? Reply to this email with your biggest inbox-placement question—we’ll cover it in a future issue.

    The operators who win the long game aren’t the ones who send the most. They’re the ones who still land in the inbox after two years.