Ghost newsletters: why a newsletter breaks as the subscriber base grows
Ghost newsletters work predictably at the start: a base of a couple thousand addresses, sending in batches, emails get delivered. Problems begin not with content, but with infrastructure — as soon as the base crosses tens of thousands of subscribers, and sending frequency grows.
The first thing to degrade is email deliverability: mail providers stop trusting the domain, and part of the sends silently goes to spam or bounces.
Then the domino effect kicks in. The sending queue piles up faster than it is processed, workers hit the limits of mail services, and domain reputation drops from spikes in complaints and unsubscribes.
One unsuccessful issue to a large base — and the domain ends up on blocklists, after which delivery degrades for all emails, including transactional ones.
A separate category of failures is growth without segmentation. When a newsletter goes out to everyone in a single stream, the share of inactive addresses grows, and it is they that generate most of the bounces and complaints.
Domain reputation rests not on volume, but on the ratio of delivered, opened, and complained — and this ratio is managed by the sending architecture, not by the text of the email.
We break down how this is closed: a warmed-up domain, separate streams for newsletters and transactions, segmentation by activity, queue control, and reputation monitoring before providers start cutting sends.
What a properly configured newsletter delivers
A configured newsletter is not a "send button" but a combination of domain authentication, reputation warming, and subscriber segmentation.
When these three parts are brought into a single system, measurable metrics change: the share of delivered emails grows, unsubscribes fall, and peak sends stop landing in the spam folder.
The key effect is growth in the share of delivered emails. Spam filters look at email signatures, the sending history from a domain, and recipient reactions.
If the domain is configured correctly and sending proceeds at a steady pace, emails reach the inbox instead of settling in "Promotions" or "Spam." The difference between "sent" and "delivered" is exactly the metric that shows whether the newsletter is working at all.
Unsubscribes decrease when an email reaches those who expect it and at the moment when it is appropriate. Behavioral segmentation — opened, clicked, purchased, went silent — helps avoid flooding inactive subscribers and avoid losing active ones.
Sender reputation grows when complaints are rare and engagement is high: email services see this and begin to let emails through more readily.
Sending stability matters at peaks: a launch, a promotion, an announcement. If the infrastructure is not designed for a one-time increase in volume, some emails go out with a delay or are lost altogether.
A configured newsletter maintains a steady pace both for regular issues and for mass sends — without drops in delivery.
Ghost newsletters gives the editorial team a convenient interface, but it needs to be properly connected to the email domain and analytics.
Then each issue turns into a manageable channel: you can see how many were delivered, how many were opened, where people unsubscribed — and what to fix in the next one.
Newsletter delivery methods: comparing the options
Ghost has three fundamentally different paths for email delivery, and the choice between them determines where you will deal with delivery failures — on your side or on the contractor's side.
The built-in newsletter module covers the scenario of "subscribers in the same database as the content": a post turns into an issue, segments are built by labels and paid status, and open and click statistics sit right next to the material.
An external sending service is connected when you need your own domain warm-up logic, granular per-customer analytics, and automated email sequences.
Sending on your own through your own mail server gives you full control over the flow, but shifts IP reputation and unsubscribe handling onto you.
| Option | When it fits | Limitations |
|---|---|---|
| Built-in newsletter module | A single subscriber base, regular issues, minimal integrations | Weak sequence automation, limited segmentation, statistics without end-to-end analytics |
| External sending service | You need email scenarios, A/B testing of subject lines, detailed deliverability reports | Synchronizing the base and subscription statuses, duplicating templates, dependence on plan limits |
| Sending on your own | Strict data storage requirements, non-standard sending logic | IP and domain reputation is entirely on you, you need bounce monitoring and complaint handling |
In practice, the choice is rarely either-or: the built-in module handles editorial issues, while an external service takes on transactional emails and sequences.
When setting up newsletter delivery, the first thing we establish is who owns the subscriber base and how unsubscribes are synchronized — it is precisely at this junction that addresses are most often lost and the share of complaints grows.
Next, we set up subscription confirmation and stream separation so that problems in one channel do not affect the others.
Stages of setting up a mailing under load
We start with a configuration audit: we look at how sending is currently organized, which domains and subdomains are involved, whether email authentication records are configured, how subscriber lists are formed, and what happens with unsubscribes and bounces.
At this stage, it is important to understand the real size of the database and the load profile — a one-time mailing to the entire database and a series of scheduled emails behave differently, and the scheme for them is designed separately.
- Configuration audit. We record the current state of sending, domains, authentication records, subscriber sources, and bounce history. The output is a map of bottlenecks: where emails go to spam, where unsubscribes are lost, where the database grows faster than it can be cleaned.
- Scheme design. We determine how the mailing fits into the site: audience segments, triggers, schedule, connection with subscription forms and the personal account. We think through behavior during peak sending — queue, retries, cutting off inactive addresses.
- Sending setup. We connect the domain, configure email authentication, templates and variables, and assemble scenarios for transactional and bulk mailings. We test each scenario on a test group before launching to the entire database.
- Deliverability check. We send control emails to a pool of mailboxes across different providers, and look at where the email lands and how it is displayed. We separately check unsubscribe links and bounce handling — this is what directly affects domain reputation.
- Load check. We run sending at a volume close to real, and look at how the queue behaves: whether there are delays, whether emails are lost during a peak, whether the system manages to process unsubscribes.
- Handover of regulations. We provide documentation on working with the mailing: how to add segments, how to read deliverability statistics, what to do during a spike in bounces. The client's team then runs the mailing independently.
- Support. After launch, we monitor deliverability metrics and, if necessary, adjust the scheme — domain reputation changes over time, and settings require periodic review.
This order makes it possible to launch a mailing without a drop in deliverability and with clear operating rules on the client's side.
What the client receives after setup
Setting up email campaigns is not a matter of "turned it on and it works" — it is a set of artifacts that the system lives by and is handed over with.
Below is what remains in your hands after the project is delivered: every item can be opened, verified, and handed over to another engineer without verbal explanations.
- Campaign configurations — working sending profiles: domains, email templates, settings for subscriber segments and triggers. Everything is in a repository with a change history, not in one person's interface.
- Routing schemes — a map of how an email travels from subscription to delivery: which events trigger sending, how unsubscribes and bounces are handled, where external delivery services are connected.
- Access policies — roles for editors, authors, and administrators: who can change a template, who can see the subscriber base, who manages sending keys. The principle of least privilege is documented in writing.
- Documentation — architecture description, instructions for typical operations (add a segment, change a template, connect a new domain), and analysis of non-standard situations.
- Maintenance regulations — what is checked and how often: domain reputation, delivered email rate, list growth, unsubscribe correctness. With an indication of who responds and within what timeframes.
- Monitoring and alerts — configured thresholds for delivery failures and spam complaints, so that a problem surfaces before the domain ends up on blacklists.
- Recovery plan — backups of configurations and the database, the procedure for action in case of a sending failure, and a verified rollback to the previous working version.
We hand over each artifact in the form in which your team or another contractor will accept it: without being tied to a specific contractor and without hidden dependencies.
If you plan to handle part of the work yourself, we will show what your side is responsible for and what remains on support.
Describe the task — we will come back with an estimate and a plan, including a list of artifacts for your case.
Case study: how deliverability grew after reconfiguration
The client — a publisher of an industry newsletter on Ghost — came with a classic picture: emails go out, but some subscribers never see them, and each issue is prepared almost manually.
They assembled the issue in the editor, manually inserted links, tracking parameters, and images, then manually cleaned the list of unsubscribes and "stuck" addresses.
Preparing an issue took about six hours, and every time there were discrepancies between the test and production sends.
What it was like before reconfiguration
The sending domain was not separated from the website domain, SPF and DKIM pointed in different directions, and DMARC was set to monitoring mode. Providers placed some emails in "Promotions" and "Spam," and the delivered rate hovered around 82%.
A separate problem was the growth of blocks: during sharp spikes in sending to a large segment, some addresses received a rejection, and those addresses remained on the list, continuing to damage reputation.
What was changed
The streams were separated: transactional emails and bulk issues went through different subdomains, each with its own authentication records. A warm-up of the new subdomain was set up in small batches, automatic cleaning of inactive addresses and bounce handling were connected.
Issue assembly was moved to templates with ready-made blocks and variables — the editor stopped assembling the issue manually.
| Metric | Before | After |
|---|---|---|
| Delivered email rate | ~82% | ~97% |
| Issue preparation time | ~6 hours | ~1.5 hours |
| Blocks per month | dozens of addresses | isolated cases |
| Manual operations during assembly | almost all | template and check |
Two months after reconfiguration, the delivered rate stabilized at 97%, and the number of blocks dropped to isolated cases. Issue preparation time fell fourfold — the editor spends it on the text, not on technical assembly.
The domain reputation stopped declining after large sends, and the newsletter stopped being a bottleneck in the editorial workflow.
How does built-in mailing differ from an external service?
Built-in mailing is part of the application itself: subscribers, email templates, and sending history reside in the same database as the site's content.
Sending is handled either by an in-house mail node or a connected transport, but the subscription logic, segmentation, and triggers remain within your perimeter.
An external service is a separate system with its own subscriber database, to which data is regularly transferred via a programmatic interface, and emails are sent from someone else's infrastructure.
The architectural difference manifests in where the "source of truth" about the subscriber lives.
With the built-in option, subscription status, interest tags, and open history change in a single transaction with content publication — desynchronization between the site and the mailing cannot occur by definition.
With an external service, synchronization appears: it must be designed, conflicts handled, failed calls retried, and care taken that an unsubscribed person does not receive the next email.
Provider dependency is the second divide. An external service dictates its own pricing tiers, limits on the number of contacts and sending frequency, and when switching providers you have to migrate the database, re-warm the domain reputation, and rewrite the integration.
Built-in mailing creates no such dependency: you change the transport node without touching subscribers and templates.
The complexity of maintenance is distributed differently.
An external service relieves the team of work on IP reputation, queues, and feedback from email providers — but adds an integration layer and debugging of "why the email didn't go out." The built-in option requires the team to handle queues, retries, and bounce processing themselves, but diagnostics run through a single log rather than two systems.
The practical selection criterion is simple: if mailing is a supporting channel and the team is small, an external service is cheaper in terms of engineers' attention.
If there are many emails, segmentation is complex, and instant reaction to user actions matters, a built-in perimeter provides more control and fewer points of failure.
Common technical concerns before starting
Before starting, the same questions almost always come up: what will happen to the already deployed campaign, how to make sure the domain isn't on blacklists, and which metrics should be used to judge the result. Below are short answers that most often address the concerns of technical leaders.
We already have a campaign deployed — will we have to start from scratch?
No. We connect to the current configuration, take dumps of lists and templates, and migrate subscriber history and segments without data loss. Then we set up sending through a dedicated subdomain so that the reputation of the main domain isn't mixed with bulk emails.
We switch over in stages: first a test segment, then the full flow — if something goes wrong, rollback takes minutes.
How is domain reputation checked before launch?
We look at sender authentication records, the presence of a reverse DNS zone, and the complaint history by IP. Separately, we check the domain and subdomain against public blacklists and reputation aggregators.
If the domain is "cold" or tarnished, we warm it up gradually: we increase sending volume on a schedule, monitor the spam placement rate, and adjust the pace. This way reputation is restored predictably, not in a sudden burst.
Which metrics are tracked after launch?
Deliverability and the spam placement rate — that's the baseline level of health.
Then we look at opens, clicks, unsubscribes, and complaints broken down by segment, not "on average across the board." Separately, we track base growth dynamics and activity over time — these show which topics and frequencies work and which burn out the audience.
Metrics are collected into a single dashboard so decisions are made based on numbers, not gut feelings.
What about access and security when the campaign is handed over to us?
We work through separate accounts with limited permissions and action logging. Sending keys are stored in a secure vault, and access to the dashboard is protected by two-factor authentication.
Upon completion of the work, all temporary access is revoked, and the configuration and documentation remain with you.
If your question isn't here — describe the task, and we'll get back to you with an estimate and a plan.
Let's discuss your email campaign task
To come back with an estimate and a plan rather than generalities, we need a brief technical snapshot of your current configuration.
Describe how your email campaigns are set up now: where the subscriber base lives, how segments are formed, which emails go out automatically and which you assemble manually. That is enough to understand the scope of work and avoid reinventing what already works for you.
Separately, spell out the goals of your email campaigns — the architecture depends on them.
A weekly digest to the entire base, transactional emails after registration, and a behavior-based email series for readers require different scenarios, different segmentation logic, and different deliverability controls.
Once the goal is articulated, we propose a concrete scheme rather than a set of abstract improvements.
What is worth attaching to the task description:
- current configuration: how the sending domain is connected, whether email authentication records are set up, where the subscriber base is stored;
- size and structure of the base: how many addresses, how they are split into segments, how unsubscribes are handled;
- existing scenarios: which emails go out automatically, triggered by which event, with what delay;
- templates and design: where they are assembled, who makes edits, how easy it is to change text without a developer;
- analytics: which metrics you already track and which decisions you make based on them;
- constraints: integrations with external systems, data retention requirements, team access;
- goals for the near term: base growth, sending frequency, new scenarios that need to be launched.
Based on this snapshot, we will come back with an estimate and a work plan: what we do in the first stage, what can be launched in parallel, where data or access is needed on your side.
Describe your task — and we will propose a scheme tailored to your configuration rather than a universal template.
