Guides
Lifecycle marketing, the practitioner's way.
Long-form guides on the topics lifecycle marketers actually lose sleep over. Each draws from the Orbit methodology library and a decade of operator experience, not vendor blog posts.
Courses
10 curated paths through the guide library.
Three foundational levels and six topical deep dives. Each path ends in a quiz.
Popular this week
Fresh picks every 7 daysHow to think about lifecycle programs at the portfolio level: segmentation, retention economics, program selection, and cadence.
How much does lifecycle marketing cost? The honest breakdown
Almost nobody answers this plainly, so here it is: the four buckets your money actually lands in, how ESP pricing scales as your list grows, what in-house, agency and fractional really trade against each other, and the integration bill that never appears on a quote.
9 min read
BeginnerWhat is MCP? The Model Context Protocol, explained for marketers
MCP is the standard that lets an AI assistant stop describing your ESP and start reading it. What a tool is, what a skill is, what stays on your machine and what doesn't, and the questions to ask any vendor before you hand over a production API key.
9 min read
IntermediateSwitching ESP without losing your lifecycle programs
Two questions land here constantly: "does it only work with Braze?" and "so it doesn't work with other CRMs?". Underneath both is the same worry: how much of the last two years dies if we move platforms. Here's what survives a migration, what doesn't, and how to build so the answer stays in your favour.
9 min read
IntermediateRedacting PII before it reaches your AI tools
People paste API keys, customer emails and client-named file paths into marketing chat boxes without thinking about it. If your stack forwards that text to an analytics tool or stores it raw, you've collected data you never intended to hold. Here's the redaction discipline that stops it, and the questions to ask any AI vendor about what their telemetry carries.
8 min read
BeginnerWhat is lifecycle marketing? A field guide for operators starting from zero
If you're new to CRM and lifecycle, the field reads like a pile of acronyms and vendor demos. It's actually one simple idea executed across five canonical programs. Here's the frame that makes the rest of the library make sense.
10 min read
IntermediateChoosing which lifecycle programs to build first
New lifecycle lead, empty Braze account, a laundry list of programs you could build. The question nobody trains you for is which to build first. This is the selection framework: by business type, by team size, by data maturity, and the programs I'd actively wait on.
11 min read
IntermediateBuilding a personal chief-of-staff AI on Claude Routines
A real chief of staff used to mean a salary line on an exec's budget. Anthropic's Routines feature, Claude running on a schedule with access to your work tools, pulls the job inside reach of one operator. This is the architecture: morning brief, hourly interactive layer, midday drift check, evening debrief with end-of-day reconciliation, Sunday weekly review. Plus the draft-react protocol that lets the assistant act without auto-sending, calendar work blocks that double as the task tracker, and memory files the system writes into. Brain in a GitHub repo, runtime in claude.ai, no servers.
14 min read
BeginnerSegmentation strategy: beyond RFM
RFM is the floor of audience segmentation, not the ceiling. Every program that stops there ends up describing what users already did without ever predicting what they'll do next. Here's the segmentation stack that actually drives lifecycle decisions, and how to build it in Braze without ending up with 400 segments nobody understands.
10 min read
BeginnerRetention economics: proving lifecycle ROI to finance
Lifecycle programs get deprioritised when they can't defend their impact in dollars. The four models that keep the budget: LTV, payback, cohort retention, incrementality, and the four-slide pattern that wins a CFO room.
10 min read
IntermediateLifecycle marketing for flat products
The standard lifecycle playbook assumes weekly engagement and tidy stage progression. Most real products aren't shaped like that. This is how to design lifecycle, the messaging program that nudges users through their relationship with a product, for things people use once a year, once a quarter, or whenever they happen to need you. The textbook quietly makes those programs worse.
10 min read
BeginnerThe cadence question: how often should you email?
Everyone asks how often to email. Almost nobody answers it properly, because it's the wrong question. Cadence is a consequence of five other decisions you probably haven't made yet. Here's the version of the debate that resolves.
9 min read
IntermediateBraze, Iterable, Customer.io, HubSpot: what each actually gets right and wrong
Every ESP vendor's deck claims a category leader position. None of them mean it the way you'd want. Each platform suits a specific shape of program, and the migration disasters happen when a team picks the one with the prettiest deck instead of the one their actual use case lives inside.
11 min read
IntermediateThe lifecycle audit: a 30-point checklist
Lifecycle programs, the automated email, push and SMS journeys that move customers from signup to repeat purchase, decay quietly. A recurring audit is the cheapest discipline that catches drift before it turns up in the revenue deck. Here's the 30-point list, grouped by severity, that takes three hours the first time and ninety minutes after that.
11 min read
IntermediateBuilding a lifecycle team: the roles, the order, the size
Lifecycle is a craft, an ops function, and a strategic lever all at once. Most teams accidentally end up with three people holding overlapping halves of the role. Here's the deliberate version: who to hire first, what triggers the next one, and when CRM stops belonging in brand marketing.
9 min read
IntermediateB2B lifecycle marketing: what changes when the buyer isn't the user
B2B lifecycle looks like B2C on the surface, emails, flows, segmentation, but the mechanics underneath are different. Buying committees, account-level intent, sales hand-offs, and product-led overlaps all change the playbook. Here's what's actually different.
10 min read
IntermediateThe lifecycle metrics dashboard: what to track, what to ignore
Most lifecycle dashboards show forty metrics and answer none of the questions the team actually has. A good one shows eight, and each one tells you what to do next. Here's the eight-metric dashboard that runs a real lifecycle program.
8 min read
IntermediateCRM vs CDP: which tool do you actually need?
Vendors sell CRM, CDP, marketing automation, and ESP as if they're four shapes of the same box. They aren't. Here's what each one actually does, where it falls over, and the decision rule for picking one first.
9 min read
BeginnerThe monthly newsletter still works: here's the structure
Email newsletters have been declared dead every year since 2015. They're not. A well-run monthly newsletter does real work for a lifecycle program: brand equity, re-engagement, the non-promotional relationship that makes every other send land. Here's what separates the newsletters worth sending from the ones that feel mandatory.
7 min read
IntermediateQuarterly planning for lifecycle: what actually goes in the plan
Most lifecycle roadmaps are calendar lists of campaigns. A real quarterly plan is different: priorities tied to metrics, with tests, investments, and explicit trade-offs. Here's the format that produces decisions, not lists.
8 min read
BeginnerLifecycle for startups: the three flows to build before anything else
Early-stage programs waste months building the wrong lifecycle flows. Here are the three that compound value at every stage, welcome, trial-to-paid (or first-repeat), and winback, and why everything else can wait.
6 min read
IntermediateReporting lifecycle to executives: the monthly update that actually lands
Most lifecycle reporting to execs is a 20-slide deck of campaign-level charts that nobody remembers a week later. The fix is structural, not quantitative. Three numbers, two decisions, one ask. Here's how to build the report that produces ongoing investment instead of polite nods.
6 min read
AdvancedAI personalisation at scale: the architecture that actually works
Every ESP now sells an AI personalisation layer. Most teams turn it on and quietly notice the lift is smaller than the sales deck promised. The model isn't the problem. The plumbing underneath is. Here's the data, content and activation stack that decides whether AI personalisation moves revenue or just moves dashboards.
9 min read
AdvancedPredictive models in lifecycle: churn, propensity, and recommendations without the magic
Predictive models in lifecycle are mostly three things: churn risk, conversion propensity, and product recommendations. Each one earns or loses its place based on whether its score actually changes a decision. Here's the operator view of what's worth deploying, what to expect from ESP-native suites, and when to build your own.
9 min read
The plumbing that decides whether any of this work reaches a human. Sender reputation, authentication, and the rules mailbox providers actually enforce.
The deliverability mental model: one picture for authentication, reputation, content, and monitoring
Most deliverability guides cover one piece: SPF, DKIM, DMARC, BIMI, reputation, warmup, and assume you already know how the pieces fit. This is the picture they assume: how a mailbox provider decides whether your email reaches the inbox, what each acronym actually does inside that decision, and where to look first when placement tanks.
12 min read
BeginnerEmail deliverability: the practitioner's guide
Deliverability isn't a setting. It's the running total of every send decision you've made since you bought the domain. Four pillars hold it up. Break one and the whole program starts leaking.
12 min read
AdvancedIP warm-up in Braze: the playbook that actually holds
A fresh dedicated IP has zero reputation on day one. Most warm-up guides fixate on ramp speed and ignore the harder question: which users get the send each day. Here's the schedule, the Random Bucket Number trick, and the day-10 mistake that ruins most of them.
11 min read
IntermediateWhy Gmail clips emails at 102KB (and how to stop it)
Gmail has been clipping emails over 102KB since 2013. The 'View entire message' link almost nobody clicks is where your unsubscribe, secondary CTA, and legal footer go to die. Here's how bytes actually pile up and the discipline that keeps every send under the threshold.
8 min read
AdvancedApple Mail Privacy Protection, four years in
Apple broke the open rate in 2021. Half the lifecycle industry is still pretending it didn't happen. Four years on, the programs that actually adapted are beating the ones that kept optimising a metric that doesn't exist anymore.
8 min read
IntermediateThe unsubscribe page is the most important page in your lifecycle program
The page every lifecycle team ignores is the one quietly deciding sender reputation, suppression-list quality, and the fate of next quarter's deliverability. A short defence of why it deserves the ten-minute rebuild.
7 min read
AdvancedSPF, DKIM, and DMARC explained for lifecycle marketers
Three DNS records decide whether Gmail trusts your marketing email or quietly bins it. Gmail and Yahoo made all three mandatory for bulk senders in 2024 and the grace period is over. This is the practitioner's explainer: what each record does in plain English, how they interact, and the setup order that won't accidentally block your own mail.
10 min read
AdvancedDedicated vs shared IP: the real decision
Every ESP sales conversation pitches the dedicated IP as an upgrade. For most lifecycle programs it isn't: it's a trade, and often a losing one. Here's the volume threshold that actually justifies dedicated, the risks most teams don't anticipate, and when the shared pool is genuinely the better call.
8 min read
IntermediateList hygiene: the six-rule policy
List hygiene isn't cleanup; it's a continuous policy that runs automatically. Here's the six-rule policy every lifecycle program should have written down, each tied to a specific deliverability outcome.
8 min read
IntermediateBounce rate management: the thresholds and the fix order
Bounce rate is the easiest deliverability metric to read and the easiest to misread. Here's what each bounce type actually means, the thresholds that trigger real problems, and the fix order when your rate climbs.
8 min read
AdvancedSpam complaints: the playbook for detecting and reducing them
Spam complaints are the hardest-hitting negative reputation signal in email. They compound faster than bounces and recover slower. This is the playbook: what actually triggers them, how to catch them early, and the four levers that reliably bring the rate back down.
9 min read
AdvancedDomain vs IP reputation: which one actually matters
Deliverability reputation is two parallel scores, not one. IP and domain behave differently, recover differently, and the balance between them has shifted hard toward domain over the past five years. Here's what that means for what you monitor and how you warm up.
8 min read
AdvancedGoogle Postmaster Tools: a walkthrough for people who actually send email
Postmaster Tools is the single most valuable free deliverability tool and most programs either ignore it or misread the charts. Here's what each tab actually says, what to act on, and what to stop looking at.
9 min read
IntermediateGmail Promotions tab: is landing there actually bad?
The Promotions tab has been a marketing bogeyman since 2013. The honest answer: it's usually fine, sometimes a problem, and the fix is almost never 'try to escape the tab'. Here's how to think about it.
7 min read
AdvancedInbox placement testing: seed lists, their limits, and what to do instead
Seed-list tools report '82% inbox, 18% spam' and programs treat that as gospel. It's not. The number is directionally useful and literally wrong, and most programs read it more literally than they should. Here's what it can and can't tell you.
8 min read
AdvancedBIMI and VMC: the verified-logo upgrade worth doing properly
BIMI puts your logo next to your mail in Gmail, Apple Mail, Yahoo and Fastmail. A Verified Mark Certificate adds the blue checkmark that signals your sender identity has been independently verified. Together they convert your DMARC investment into something every user can see. And for any program serious about brand and deliverability, the answer in 2026 is yes, do it.
10 min read
IntermediateBounces vs blocks vs deferrals: what your ESP's error codes actually mean
SMTP error codes are the mechanical reason emails don't arrive. Most programs lump them all into 'bounces' and miss the signal. Here's the actual taxonomy: hard bounce, soft bounce, block, deferral, and what each one tells you.
8 min read
AdvancedSMTP vs API sending: which integration pattern your program needs
Two ways to push mail through an ESP: SMTP, which is old, universal, and boring in the good way, or API, which is faster and feature-rich but tied to the vendor. Most mature programs end up running both. Here's how to pick which goes where.
7 min read
AdvancedReputation recovery: the 90-day playbook for dropping from High to Low
Domain reputation at Low or Bad isn't a problem you fix this week. It's a 6–12 week project of disciplined sending to engaged users only, while the reputation signals slowly reset. Here's the plan.
9 min read
The canonical lifecycle programs: onboarding, activation, win-back, transactional. What works, what doesn't, and where the leverage is.
Email popup timing: fire on a signal, not on a stopwatch
Most lead-capture modals fire on a blind timer a few seconds after page load. That timer selects for the visitor who is still there and still busy, the most engaged person on the site, and interrupts them. Here's the intent-aware version, including the accessibility duties nobody reads before setting aria-modal.
8 min read
IntermediateOnboarding flows: signup to activated
Most onboarding programs fail in the same three ways: no activation metric, no awareness of what the user just did in-product, and a sequence that won't stop once the user has clearly activated. Fix those three and the program starts moving signups to activated users in numbers you can actually defend.
10 min read
BeginnerThe first 72 hours decide who activates
Activation isn't a seven-day project. It's a 72-hour race most teams lose without noticing. Why the window is that short, what to watch inside it, and how to intervene while users are still reachable.
9 min read
IntermediateWin-back flows: 12 patterns that earn their place
Win-back is the highest-ROI program most lifecycle teams underbuild. Twelve patterns that work, when each one fits, and the sunset policy that stops the program quietly eating your sender reputation.
11 min read
BeginnerTransactional emails: the highest-engagement messages you ignore
Order confirmations, password resets, receipts, shipping updates. Transactional emails post open rates two to three times higher than marketing sends, and most lifecycle teams have never touched them. Effort is going to the wrong place.
10 min read
BeginnerThe welcome email sequence: the 7-day shape that actually moves new signups
Most welcome sequences over-pitch, under-onboard, and keep firing long after the user has either started using the product or wandered off. Here's the 7-day shape that gets new signups to a real first action: shorter, sharper, conditional on what they actually did, plus the stop rules that keep it from training people to ignore your email.
9 min read
IntermediateAbandoned cart emails: what actually works
Cart abandonment is the easiest program to get wrong because the defaults work well enough to hide the problem. Here's the structure that actually moves incremental revenue: timing, sequencing, and the discount policy most teams have backwards.
9 min read
IntermediatePost-purchase emails: what to send after the receipt
Post-purchase is the highest-engagement window in the entire customer relationship and most lifecycle programs spend it sending a receipt, a generic welcome, and then silence. Here's the 30-day sequence that actually earns the second purchase.
8 min read
IntermediateReactivation vs win-back: the distinction that changes the program
Reactivation and win-back get used interchangeably. They're different audiences with different psychologies and different conversion patterns. Running the same program for both is how one of them fails.
8 min read
IntermediateBrowse abandonment: the program that sits between ads and cart
Browse abandonment catches the users who viewed a product and left without adding to cart. Smaller per-user lift than cart abandonment. Ten to twenty times the trigger volume. For most programs it's the biggest revenue lever you haven't shipped yet.
8 min read
IntermediateReferral program emails: the three flows that make it work
A referral program lives or dies on the lifecycle messaging, the automated emails that prompt, deliver, and confirm, wrapped around it. Three flows do the work: inviter prompt, invitee welcome, reward confirmation. Get the timing and copy right on each and conversion roughly doubles without anyone touching the offer.
8 min read
IntermediateSunset sequences: how to say goodbye without burning the list
A sunset is the last-chance messaging to a dormant user before permanent suppression. Run it well and you recover 5–10% of the audience; run it badly and it's a complaint magnet. Here's the three-message structure.
8 min read
AdvancedLoyalty program emails: the six touches that make a loyalty program work
A loyalty program without lifecycle emails is a badge on the checkout page that nobody remembers. The emails are what make it feel like a program. Six touches turn a points system into real behaviour change: here's the shape, the cadence, and the stop rules.
8 min read
IntermediateTrial-to-paid: the seven-email sequence that converts 20%+ of free users
Trial conversion is the most financially leveraged flow in SaaS. Every percentage point compounds directly against CAC. Here's the seven-email sequence that reliably moves trial conversion from 5% to 20%+.
9 min read
IntermediateReplenishment emails: the lifecycle flow that buys itself
Replenishment emails remind users to re-order a consumable before they run out. Done right, they generate the highest revenue-per-send in any lifecycle program because purchase intent is already established. Here's the timing, data, and copy.
7 min read
AdvancedVIP customer lifecycle: how to treat the 5% of users who drive 40% of revenue
Your highest-value customers need a different lifecycle than everyone else. Most programs send them the same broadcast cadence as a cold signup. Here's the VIP-specific flow: what to send, what to skip, and how to protect the relationship that's paying the bills.
8 min read
IntermediateProgressive profiling: asking users for data without scaring them off
Progressive profiling means collecting user data over time in small, contextual prompts instead of one giant signup form. Done well, it transforms personalisation data quality. Done badly, it's irritating surveillance with extra steps.
7 min read
IntermediatePrice increase emails: how to raise prices without a churn spike
A price increase is one of the highest-risk lifecycle moments your program will ever run. Done wrong, it triggers churn, public complaints, and a reputation dent that outlasts the extra revenue. Done right, most users accept the change without friction. Here's the sequence that works.
8 min read
BeginnerBirthday and anniversary emails: the easy wins most programs don't run
Birthday and anniversary emails are low-effort, high-response lifecycle triggers that most programs never set up. Here's the playbook: what to send, what to offer, and how to handle the 40–70% of users who didn't give you a birthday.
6 min read
IntermediateFree shipping threshold emails: the cart-value nudge that reliably lifts AOV
A user with $45 in their cart and a $50 free-shipping threshold will add another item to cross the line, if they realise it. The right email at the right moment surfaces the gap and reliably lifts AOV by 5–15%.
6 min read
IntermediateReview request emails: the timing that actually produces reviews
A review request at the wrong time gets ignored. At the right time, it converts at 15–25% into a submitted review. Here's the timing, the message pattern, and why incentivising reviews almost always backfires.
7 min read
IntermediateProduct launch email sequence: the five emails that actually sell a new product
A product launch with one big announcement email captures a fraction of the addressable audience. A proper five-email sequence catches multiple attention windows, builds anticipation, and converts the users who needed a second or third touch. Here's the structure that reliably outperforms the single-send version.
8 min read
IntermediateSubscription churn saves: the three-moment intervention that retains 20%+ of cancellers
A subscription cancellation is three distinct moments: pre-cancel intent, the cancel action itself, and post-cancel. Each needs its own intervention. Most programs only address the middle one, and leave the other two on the table.
8 min read
The writing and building of lifecycle messaging: naming, Liquid, SMS, personalisation that doesn't feel invasive.
Connect Claude to Braze: the read-only-first setup
Connecting Claude to Braze is two strings and a list of checkboxes: a REST API key, your cluster endpoint, and the permissions you tick when you create the key. Those checkboxes are the whole security model. Here is which ones to grant first, which to withhold, and how to verify what the integration can actually see.
9 min read
IntermediateBraze naming conventions that survive a Friday afternoon
Every Braze workspace eventually becomes an archaeological dig. The convention that actually holds is four dimensions, six seconds to apply, and enforced by tooling rather than a Notion page nobody reads.
9 min read
IntermediateLiquid for lifecycle marketers: the complete Braze reference
Every personalised field in every Braze message runs through Liquid. Get it right and personalisation quietly improves every send. Get it wrong and 50,000 people see 'Hi {{${first_name}}}'. This reference covers the syntax and the production habits that stop that happening.
11 min read
IntermediatePersonalisation that doesn't feel creepy
There's a line between personalisation that earns trust and personalisation that breaks it. It's not where most people think it is: it's about how you signal what you know, not what you know. Here's the line, how programs cross it without noticing, and the patterns that keep you on the right side.
9 min read
IntermediateThe SMS playbook from the operator's seat
SMS is the highest-engagement and highest-risk channel in the lifecycle stack. Here's the compliance architecture, the copy discipline, and the frequency rules that keep SMS from destroying the goodwill it's uniquely positioned to create.
10 min read
BeginnerSubject line anatomy: the four parts every line that performs shares
Most subject-line advice is decoration tips: emoji, length, numbers. The lines that actually get opened share a structural pattern. Four parts in a specific order, the three distortions that ruin it, and the four rules that keep A/B tests honest.
8 min read
IntermediatePush notification copy that actually gets tapped
Push is the highest-interrupt channel in the stack. A bad push burns goodwill in under a second; a good one feels like a useful nudge from a friend. This is the copy discipline: specific words, specific structures, specific anti-patterns that reliably get a user to turn your notifications off for good.
8 min read
BeginnerPreheader text: the second subject line most programs ignore
The preheader is the snippet shown next to the subject line in the inbox preview. Treat it like a second subject line and you double your hook. Treat it like an afterthought and it says 'View this email in your browser'. Here's how to write preheaders that actually earn the open.
7 min read
IntermediateEmail dark mode: the four render modes and how to not break any of them
Dark mode in email is four different render behaviours across major clients, each with its own logic. Design without knowing which mode you're hitting and roughly half your audience sees something you never approved. Here's what each client does and the defensive rules that survive all of them.
9 min read
IntermediateMobile email design: 65% of opens are on a phone. Design for that
Two-thirds of email is opened on mobile. Most designs still start with desktop and hope it collapses. Here are the mobile-first rules that reliably produce emails that read, click, and convert on a phone.
8 min read
IntermediateEmail accessibility: the seven rules that make your emails readable by everyone
Roughly fifteen percent of your audience opens your email with a screen reader, on a cracked phone in direct sunlight, or with images blocked at the corporate gateway. Most programs accidentally design around them. Seven rules, most of them cheap, all of them learnable in an afternoon, close the gap.
8 min read
IntermediateTransactional email anatomy: the five sections every transactional needs
Transactional emails, receipts, password resets, shipping updates, open at 3–5x the rate of marketing and carry more brand signal per send than anything else in the program. Most teams treat them as ops artefacts and miss the leverage entirely. Here's the five-section anatomy that works across every transactional type.
8 min read
BeginnerClaude with Orbit vs Claude without: same model, one of them can check its work
On its own, Claude writes fluent lifecycle work it has no way to verify: plausible Liquid, plausible Braze steps, HTML that looks right and clips in Gmail. Here is a task-by-task comparison of what changes once the model can open the email, read the platform's real constraints, and tell you it was wrong.
10 min read
BeginnerBrand voice in lifecycle: how to sound like you, not the generic SaaS CRM voice
Lifecycle emails, the automated sequences that go out on signup, after a purchase, when a cart is abandoned, drift toward a polished, generic SaaS voice because it's the default in every template library. Here's how to actually write in your brand's voice across an entire program.
8 min read
BeginnerThe email copywriting pyramid: write for the 5-second reader first
Most recipients give an email five seconds before they engage or delete. The email has to land its point at that depth and still reward a longer read. The inverted pyramid, conclusion first, detail after, is how.
7 min read
BeginnerEmojis in subject lines: when they help, when they hurt
One well-placed emoji lifts open rate a few percent. Three reads as spam and drops it. The honest version of the emoji question is smaller and more specific than the debate suggests: here's the pattern that actually survives testing.
6 min read
BeginnerPlain-text email versions: why they still matter in 2026
Every HTML email should ship with a plain-text twin: the same email rendered as bare text, no styling. Most ESPs auto-generate one, and most of those auto-generated versions are garbage. Here's why the plain-text version still matters in 2026 and how to make the version you ship actually work.
6 min read
IntermediateCustom attributes: the data design that decides what your program can do
Custom attributes are infrastructure. Designed well, they enable every future campaign. Designed badly, they become the reason "can we segment on X?" is a multi-week engineering project instead of a 15-minute one. Here's the design discipline that prevents the mess.
7 min read
AdvancedGenerative AI for lifecycle content: where it earns its place and where it embarrasses you
Generative AI inside lifecycle ESPs has moved from novelty to default in 18 months. BrazeAI (formerly Sage AI), Iterable Copy Assist, Klaviyo's subject line generator: they all promise per-message copy at scale. Some uses are genuinely useful. Others are a fast path to brand drift, factual errors, and reputational damage. Here's the line.
8 min read
IntermediateStripo, natively: connect your account, sync your modules, compose emails through the API
If you build emails in Stripo and edit them with Claude, you've probably been running a clipboard relay: copy HTML out, paste in, paste the result back. Orbit's native Stripo integration ends the relay. This guide walks through how the loop closes: pulling your saved Stripo modules into Orbit, letting Claude compose new emails from them, pushing the result back as an editable Stripo email, plus the two setup gotchas everyone hits the first time.
13 min read
IntermediateHow to build Stripo emails with Claude, and push them straight to Braze
Stripo is one of the most-used email builders going, and most teams still drive it by hand: drag blocks in the editor, copy the HTML out, paste it into an AI tool, paste the result back. Orbit connects Claude directly to Stripo's API instead. This guide walks the full workflow, sync your Stripo modules, compose an email in chat, verify it renders, and export it to a Braze template by name, without leaving the conversation.
11 min read
How to know if any of it is working. A/B testing discipline, measurement frameworks, and the honest version of attribution.
UTM parameters for email: the convention that still parses a year later
Five parameters, one delimiter, everything lowercase, and a builder open next to the ESP. Most UTM trouble is a naming problem in disguise, and it only surfaces when someone tries to read last year's report.
8 min read
IntermediateFirst-party email analytics: the minimum schema, and the discipline that keeps it honest
You can measure a site and the traffic your sends drive into it with three Postgres tables and no third-party pixel. What nobody warns you about is that first-party analytics fails silently: no vendor is going to tell you the column is empty. Two bugs from our own tables, and the rules we now work to.
8 min read
IntermediateA/B testing in email: sample size, novelty, and what to report
Most email A/B tests produce winners that don't reproduce. Three reasons keep showing up: under-powered samples, the novelty effect, and weak readout discipline. This guide is about designing tests that actually drive decisions instead of theatre.
10 min read
AdvancedPrice-testing through email: what's testable, what isn't
Email is the fastest place to try a new price, and the easiest place to learn the wrong lesson. What you can test cleanly, what you can't, and the measurement traps that quietly turn price tests into expensive false positives.
9 min read
IntermediateHoldout group design: the incrementality tool most lifecycle programs skip
Without a holdout, lifecycle ROI is attribution-model guesswork with a spreadsheet. With one, you get a defensible number you can actually put in front of finance. Here's how to size, run, and read a holdout, and the three mistakes that quietly invalidate the result.
9 min read
AdvancedAttribution models for lifecycle: which one to defend in which room
Attribution debates are half epistemology, half politics. Last-touch is wrong but defensible. Multi-touch is more accurate but less defensible. Incrementality is the only one that answers the causal question, and it's the slowest. Here's which model to use for which question, and why.
10 min read
AdvancedChurn cohort analysis: the one chart that tells you if retention is actually improving
A cohort retention curve is the single most useful analytical artifact in lifecycle marketing. It isolates real program impact from the compounding noise that every other metric hides, and it's the one view that survives every limitation of the simpler numbers. Here's how to build one and how to read it without kidding yourself.
9 min read
IntermediateSample size: the calculation everyone gets wrong in email A/B tests
Most email A/B tests are powered to detect effects far larger than the test could actually produce. The result: false positives and false nulls, with confident conclusions in both directions. Sample size calculation fixes this before you send. Takes 5 minutes. Here's the 5-minute version.
8 min read
IntermediateSend-time optimisation: what it really moves, and what it doesn't
Every ESP markets an STO feature and every vendor deck shows lift. The honest version: STO moves open rate 3–8%, rarely revenue, and only for certain program types. Here's when it's worth turning on.
7 min read
AdvancedFalse positives in email A/B tests: why half of winning tests don't actually win
Run enough A/B tests and some will show 'significant' lift from pure noise. Programs that ship every significant winner end up with a collection of imaginary improvements they can't tell apart from real ones. Here's how to spot the fakes and avoid the trap.
8 min read
AdvancedIncrementality testing: the measurement that tells you if a program actually works
Last-click attribution makes lifecycle look bigger than it is. Incrementality testing strips out users who would have converted anyway and surfaces the real number. This is how to design a test that produces a figure you can defend in front of a CFO.
9 min read
IntermediateSegment-based testing: when your average lift is hiding opposing effects
A winning A/B test with 4% aggregate lift might be a 20% win in one segment and a 10% loss in another. The aggregate is an average of opposing effects. Segment analysis catches it, and lets you ship the win to the segments that benefit while not shipping the loss to the ones that don't.
8 min read
AdvancedMeasuring AI personalisation lift honestly
Every vendor case study shows AI personalisation moving the numbers. Most internal post-mortems show the lift evaporating once a proper holdout is in place. The gap between the two is the measurement methodology. Here's the framework for proving, to yourself, your CFO, and the auditor, whether AI personalisation is actually earning its place.
8 min read
Want this methodology executable inside your Claude sessions? Get Orbit.