The Two-Line-Item Outbound Stack
Most outbound stacks accrete: a data vendor for contacts, an enrichment tool to fill the gaps, a sequencer to send, a dialer bolted on, and somebody's spreadsheet holding it together. Teams pick Apollo to collapse that sprawl — its B2B contact database, saved personas, and sequences with email, call, and LinkedIn steps replace three or four subscriptions with one platform where the list and the campaign live in the same place.
But there's one layer Apollo doesn't supply and you shouldn't want bundled: the sending identities themselves. The domains, mailboxes, and IPs your sequences send from deserve their own dedicated layer — because deliverability is an infrastructure problem, not a software feature. This guide covers the stack that consolidation-minded teams land on: everything above the send runs in Apollo, everything below it runs on ColdRelay, and the whole operation is two line items instead of six.
Why Consolidating Into Apollo Still Leaves One Layer to Buy
The consolidation logic is sound: when your contact data, persona filters, and sequences share one platform, a list pulled from Apollo's database flows straight into a sequence without CSV exports, field-mapping, or sync jobs between vendors. Title, industry, and signal filters become campaign inputs instead of a procurement project.
The sending layer is the deliberate exception. Apollo links whatever mailboxes you bring under Settings → Mailboxes — it doesn't provision domains, configure DNS, or manage IP reputation, and stitching that together yourself (buying domains, creating workspace seats, setting SPF, DKIM, and DMARC by hand) quietly reintroduces the operational sprawl you consolidated to escape. ColdRelay closes that gap as a single purchase: dedicated mailboxes on isolated Azure tenants with dedicated IPs, DNS pre-configured, supporting 100-150 mailboxes per domain, ready in about an hour. There's no warmup waiting period — warmup runs continuously as part of each mailbox's standard budget of 4 emails/day total, 2 outbound + 2 warmup.
The two are complementary layers, not rivals: Apollo is the data and sequencing layer — database, personas, multi-channel sequences — and ColdRelay is the infrastructure layer underneath, supplying the domains, mailboxes, and dedicated IPs those sequences actually send from.
Visit Apollo →Connecting ColdRelay Mailboxes to Apollo
Provision the sending pool on ColdRelay
Pick one or two secondary domains adjacent to your brand and provision the pool — ColdRelay supports 100-150 mailboxes per domain, and consolidating teams typically start with 25-100 mailboxes sized to their meeting targets. Everything lands on isolated Azure tenants with dedicated IPs, SPF, DKIM, and DMARC pre-configured, ready in about an hour. This is the one new vendor the consolidation adds — and it replaces domain registrars, DNS work, and workspace seats you'd otherwise juggle.
Link the mailboxes in Apollo under Settings → Mailboxes
In Apollo, go to Settings → Mailboxes and connect each ColdRelay mailbox as a linked sending account. Once linked, the mailboxes become selectable senders for any sequence, and Apollo distributes sequence email steps across them.
Set Apollo's per-mailbox daily send limits to 2
Apollo enforces per-mailbox daily send limits on linked mailboxes — set each one to 2 outbound emails per day. That mirrors ColdRelay's per-mailbox budget of 4 sends/day total, split 2 outbound + 2 warmup, with warmup handled continuously on ColdRelay's side. With the limit set in Apollo, no sequence can overdraw a mailbox no matter how large the contact list behind it.
Build saved personas and searches for each ICP
In Apollo's database, define a saved persona per ICP — title, industry, company size, and signal filters like funding rounds or job changes — and save the searches that feed each one. This is the payoff of consolidation: the persona definition lives next to the sequence it feeds, so refining an ICP updates tomorrow's prospect pull without touching a second tool.
Build multi-channel sequences and launch
Create one sequence per persona, mixing email steps (routed through the ColdRelay pool) with the call and LinkedIn task steps Apollo supports natively. Because email capacity is metered and call or LinkedIn touches aren't, structure sequences so email carries the opener and the channel mix carries the follow-up. With mailboxes linked, limits set, and personas saved, you're sending the same day the infrastructure was provisioned.
The Consolidated Apollo Playbook
Audit the stack down to two line items — and stop there
Run the consolidation honestly: the data vendor, the enrichment add-on, and the standalone sequencer all fold into Apollo, and the domain-buying, DNS-configuring, mailbox-babysitting work folds into ColdRelay. Then resist the urge to consolidate one step further by sending from your corporate workspace mailboxes — the sending layer is the one place where 'fewer vendors' costs you, because your corporate domain's reputation should never be a campaign input.
Map one saved persona to one sequence, permanently
Keep a strict 1:1 between Apollo personas and sequences. When the persona definition, the saved search that feeds it, and the sequence that works it are bound together, every metric is interpretable — a reply-rate change means the message or the market moved, not that three audiences got blended into one campaign. Retire the persona and the sequence together when an ICP stops earning its slot.
Spend the email budget on signals, not list order
At 2 outbound emails/day per mailbox (4/day total with the 2 warmup sends), your daily email capacity is fixed — so which contacts get today's sends is the highest-leverage decision in the stack. Use Apollo's signal filters to front-run the queue: contacts at companies that just raised, prospects who changed jobs in the last 90 days, accounts matching a technology install. Same sequences, same capacity, meaningfully better reply rates.
Let calls and LinkedIn carry volume the mailboxes don't
Apollo's call and LinkedIn steps draw nothing from the mailbox budget — they're free capacity in a stack where email is metered. Build sequences where lower-intent segments get a LinkedIn touch or a call task before any email step, reserving mailbox sends for prospects who've shown a signal or engaged with an earlier touch. The result is more total touches per day than an email-only motion, without provisioning a single extra mailbox.
Typical Consolidated-Stack Benchmarks (Apollo + ColdRelay)
| Metric | Benchmark | Notes |
|---|---|---|
| Inbox placement rate | 95%+ | Isolated Azure tenants with dedicated IPs, instead of sends sharing your corporate workspace's reputation |
| Reply rate on persona-targeted sequences | 2-5% | Saved personas with signal filters trend toward the top of the range; broad title-only pulls toward the bottom |
| Outbound capacity per mailbox | 2/day | 4 sends/day total per mailbox — 2 outbound + 2 warmup, with warmup running continuously |
| Touches per prospect per sequence | 8-12 | Email steps metered by the mailbox budget plus unmetered call and LinkedIn steps in the same Apollo sequence |
| Outbound stack line items | 2 | Apollo for data, personas, and sequencing; ColdRelay for domains, mailboxes, and IPs — replacing a typical 4-6 vendor sprawl |
What It Costs: Apollo + ColdRelay
Infrastructure is billed per mailbox per month, with volume tiers that drop as you scale (see the table below). Dedicated IPs, isolated Azure tenants, and pre-configured DNS are included — there's no separate domain, DNS, or IP line item to track.
Apollo is billed separately on its own per-seat plans, covering the contact database, saved personas and searches, sequences, and the dialer.
This is the budget the consolidation buys you: one subscription that scales with seats and data access, one infrastructure bill that scales with sending capacity. When finance asks what outbound costs, the answer is two line items — and doubling email capacity means adding mailboxes on ColdRelay without touching the Apollo bill.
| Mailboxes | ColdRelay price / mailbox / month |
|---|---|
| 1–199 | $1.00 |
| 200–999 | $0.85 |
| 1,000–4,999 | $0.70 |
| 5,000+ | $0.55 |
Each mailbox sends 4 emails per day — 2 outbound to prospects + 2 warmup. ColdRelay provisions mailboxes on isolated Azure tenants with dedicated IPs; Apollo handles the sending, sequencing, and inbox rotation on top.
Frequently Asked Questions
Is ColdRelay an alternative to Apollo?
No — they're complementary layers of the same stack and teams run both together. Apollo is the data and sequencing layer: the contact database, saved personas, and sequences with email, call, and LinkedIn steps. ColdRelay is the infrastructure layer underneath: the secondary domains, mailboxes, and dedicated IPs that Apollo's sequences actually send from.
We consolidated into Apollo to cut vendors — doesn't adding ColdRelay defeat the point?
It's the opposite trade. Without a dedicated infrastructure layer you don't avoid the vendor — you become it: buying domains, configuring SPF, DKIM, and DMARC, managing workspace seats, and watching reputation by hand. ColdRelay collapses all of that into one purchase, ready in about an hour, so the consolidation actually completes instead of leaving a DIY layer underneath it.
Do ColdRelay mailboxes need a warmup period before Apollo sequences can launch?
No. ColdRelay mailboxes warm continuously as part of their standard budget — each mailbox sends 4 emails/day total, 2 outbound + 2 warmup — so there's no waiting period. Link the mailboxes under Settings → Mailboxes, set Apollo's per-mailbox daily send limit to 2, and sequences can start sending the same day.
Apollo's database can pull thousands of contacts — how do we size the mailbox pool against that?
Size to sends, not to list size. At 2 outbound emails/day per mailbox (4/day total with warmup), 25 mailboxes gives 50 email touches/day and 100 mailboxes gives 200 — and Apollo's per-mailbox limits queue the rest rather than overdrawing anything. Use signal filters to decide which contacts get today's capacity, lean on call and LinkedIn steps for added touches, and scale the pool on ColdRelay when the email queue, not the list, becomes the constraint.