A staging deployment that inherits a production mail key can turn a password-reset test into a real message to a customer. A transactional email staging environment prevents that failure with environment-specific credentials, recipient controls, and tests that distinguish rendering from delivery.
Keep local capture, automated checks, provider-backed staging, and production as separate paths. Local tools such as Mailpit inspect messages without external delivery; a Volanea sk_test_ key renders and logs requests but never delivers; controlled test sends exercise delivery to an address you choose. Make staging default to blocking or rewriting recipients, not to trusting developers to remember a warning.
What a transactional email staging environment needs to isolate
Staging should let your team test application behavior and message content without giving a test job an unrestricted route to customers. That means separating the things that can fail: message construction, recipient selection, credentials, sender identity, and provider-event handling.
Consider a password-reset test using a copy of production-shaped user data. The HTML may render correctly, but the copied account can still contain a real address. Or the message may reach a tester while its reset link points to the production application. A safe setup catches both problems before the message leaves your controlled test path.
We recommend treating these as distinct controls:
- Delivery mode: local capture, render-only validation, controlled external delivery, or production delivery.
- Recipient policy: capture everything locally, rewrite staging recipients, or reject addresses outside an allowlist.
- Credentials and sender: staging secrets should not provide an unrestricted route to the production sender.
- Events and data: staging callbacks should update staging records, not customer state in production.
A subject label such as [Staging] is a useful human signal, but it is not a recipient safeguard. The stronger boundary is one that blocks an unapproved address before making a provider request.
Use a different test layer for each question
No single test mode proves everything. A local preview can reveal a broken link or missing variable, but it cannot prove that a live provider accepts the message. A real staging delivery can exercise provider events, but it should not be the default for every template edit.
Local development: capture, don't deliver
Point local development at a capture server such as Mailpit or MailHog. These tools display messages in a local inbox without external delivery, so a developer can trigger a password-reset flow repeatedly and inspect its content without contacting a mailbox.
Use capture for subject lines, HTML and plain text, links, and template substitutions. It is also a good place to check whether the message includes the expected environment hostname. Our developer tools guide describes this local-capture pattern and the safeguards that complement it.
CI: test rendering and request validation
For automated request and template checks, use a Volanea API key beginning with sk_test_. It renders and logs the message but never delivers it, making it useful for checking request schemas, templates, and validation errors in CI. It does not test delivery events or inbox placement.
For example, a CI test can submit a valid password-reset payload and assert that the expected template renders, then submit a payload without a required variable and assert that validation fails. Keep both checks free of real-recipient delivery. The email testing guide covers test keys and test-send endpoints.
Staging: deliver only when delivery is under test
Use provider-backed staging for questions that require an actual send: does the sender configuration work, does your webhook receive delivery events, or does a message arrive in a controlled test inbox? Restrict the recipient to a QA address or rewrite all staging recipients to a shared test mailbox.
Volanea's POST /v1/templates/{id}/test-send and POST /v1/campaigns/{id}/test-send endpoints send to one address and prefix the subject with [Test]. These are useful for deliberate review sends. They are different from sk_test_ requests, which render and log without delivery.
Separate configuration by environment
The deployment environment should choose the email settings. Avoid letting a request parameter, a developer's local shell, or a default configuration silently decide whether an application can deliver to customers.
A configuration split can look like this:
| Setting | Local | Staging | Production |
|---|---|---|---|
| Delivery path | Mailpit or MailHog capture | Test key, or controlled provider send | Production sending credentials |
| Recipients | Captured locally | Rewrite or allowlist | Application-selected recipients |
| Sender | Local test value | Staging sender identity | Production sender identity |
| Subject marker | Optional | [Staging] or [Test] | Customer-facing subject |
| Event destination | Local handler or none | Staging webhook handler | Production webhook handler |
Keep the application mail function consistent across environments. For example, sendPasswordReset(user, token) should call the same rendering and validation logic everywhere; configuration determines whether the result is captured, rendered without delivery, or sent to an approved test address.
Store secrets in the deployment's secret manager and fail closed if staging lacks its expected values. A missing staging API key should cause a clear deployment or send error, not fallback to a production key. Also keep staging webhook secrets separate: a staging callback must not be able to mark a production user record as bounced or delivered.
Enforce recipient safety in application code
A central recipient guard is more reliable than asking every feature developer to replace addresses manually. Apply it before the provider call and inspect every recipient field, including To, CC, and BCC. If your application sends only to one recipient, still make the guard explicit so a future feature cannot quietly add an unchecked copy recipient.
Here is a TypeScript-style example that rejects unapproved addresses in staging and labels allowed messages. The application should load the allowlist from trusted configuration rather than from user input.
const stagingRecipients = new Set(
(process.env.STAGING_EMAIL_ALLOWLIST ?? "")
.split(",")
.map(address => address.trim().toLowerCase())
.filter(Boolean)
);
function guardRecipients(
message: { to: string[]; cc?: string[]; bcc?: string[] },
env = process.env.APP_ENV
) {
const all = [...message.to, ...(message.cc ?? []), ...(message.bcc ?? [])];
if (env === "staging") {
const rejected = all.filter(address =>
!stagingRecipients.has(address.trim().toLowerCase())
);
if (rejected.length) {
throw new Error(`Blocked staging recipient(s): ${rejected.join(", ")}`);
}
}
return env === "staging" ? { ...message, subject: `[Staging] ${message.subject}` } : message;
}
For a team that prefers fewer address-management decisions, rewrite every staging recipient to one controlled mailbox instead of allowing a list. Rewriting is especially useful when staging data is copied from production: it avoids relying on every test record being synthetic. If you choose an allowlist, test additions and removals as part of the deployment configuration.
Add a CI test for the guard itself. The test should show that an allowed QA address passes, an unapproved address is rejected, and an address in BCC is treated the same as one in To. Also assert that the staging subject receives its marker and that production subjects are not modified. These checks turn the recipient policy into executable behavior rather than a wiki reminder.
Configure Volanea credentials and sender details
Volanea sends through shared Amazon SES infrastructure; customers do not configure an SES Region or manage a dedicated IP for each environment. We do not offer dedicated IPs. Separate application credentials and recipient controls still matter, but AWS account and Region procedures are not part of a Volanea staging setup.
If your application uses SMTP, Volanea's SMTP login uses volanea as the username and the project's secret API key as the password. Keep that secret in the environment-specific secret store; do not commit it to a repository, bake it into a frontend bundle, or reuse a production key in a staging deployment.
The from field accepts either a bare address, such as receipts@example.com, or a display-name form, such as Acme Receipts <receipts@example.com>. Use a staging sender identity distinct from production when configuring a controlled provider-backed test. A visible staging subject label helps testers spot the message, while the recipient guard prevents it from going to an unintended address.
If you send directly through your own Amazon SES account instead of Volanea, AWS sandbox and Region rules are relevant to that account. AWS says Support provides an initial response to a production-access request within 96 hours; resolution may take longer if AWS needs additional information. That is an AWS account process, not a Volanea customer setting.
Test the boundary in CI and during release
Test the boundary, not just the happy path. A staging configuration can appear correct while a copied production secret or an overlooked BCC field bypasses the intended policy. Run a small set of negative tests whenever you change mail configuration or recipient-handling code.
For example, a test suite can include these cases:
- A valid template payload renders the expected subject and staging URL.
- A missing required variable produces a validation error.
- An address outside the staging policy is rejected or rewritten before sending.
- A CC or BCC address outside the policy is also rejected or rewritten.
- A staging send uses the staging event handler and does not mutate production records.
- A production configuration does not add a staging marker to customer-facing subjects.
Use sk_test_ in CI for rendering and request validation. Reserve real provider sends for a release check that needs evidence of delivery handling, and target an inbox controlled by your team. For that test, record the application job or event identifier alongside the provider message identifier so an engineer can trace the request through the callback.
Keep logs useful without recording unnecessary sensitive content. Environment, template identifier, recipient policy result, and provider response identifiers can help explain a failure. Password-reset tokens and full message bodies should not be logged by default.
Compare staging volume with plan capacity
A staging environment should be included in the same sending forecast as production rather than treated as a separate free pool. Count controlled provider sends from QA, scheduled jobs, and repeated release checks. Volanea defines one credit as one email to one recipient, or two if the email has an attachment; credits reset at the start of each billing month and do not roll over.
Our pricing page offers Free at $0 with 1,000 emails every month, unlimited contacts, and all 23 MCP tools. The Free comparison includes monthly email credits, the transactional REST API and webhooks, campaigns and visual workflows, and the MCP server. The same core platform features ship across tiers; paid tiers differ in volume and additional capabilities.
| Plan | Monthly billing | Yearly-billing equivalent | Monthly email volume |
|---|---|---|---|
| Free | $0 | $0 | 1,000 |
| Starter | $5/month | $4/month | 7,500 |
| Growth | $20/month | $16/month | 50,000 |
| Scale | $149/month | $119.20/month | 200,000 |
The pricing card shows the lower yearly-billing equivalents; yearly billing costs 20% less and grants the same credits each month. The comparison table labels the monthly-billing prices, which explains the difference between Growth at $20/month and its $16/month yearly equivalent, and between Scale at $149/month and its $119.20/month yearly equivalent. For example, Growth's yearly amount is $192; 192 ÷ 12 = $16/month. Scale's yearly amount is $1,430.40; 1430.40 ÷ 12 = $119.20/month.
A forecast of 180,000 delivered emails in a month, including staging provider sends, fits within Scale's 200,000-email monthly volume. If your forecast exceeds that volume, we offer Enterprise for sending more than 200,000 emails a month, with custom monthly volume. When credits run out, sending pauses until the next month or an upgrade; there is no overage billing.
A sk_test_ request renders and logs but never delivers, while a test-send endpoint sends to an address. The pricing page defines credits around sent emails, but does not state whether render-only test-key requests consume credits; don't assume a credit treatment that isn't specified. Treat actual staging deliveries as part of your sending forecast.
Release checklist for staging email
Before deploying a staging release, check both configuration and behavior. A short gate helps catch accidental production access even when the application code itself has not changed.
- Confirm the staging deployment loads staging credentials and cannot fall back to production secrets.
- Confirm local development uses capture and CI uses render-only checks unless delivery is specifically under test.
- Run recipient-guard tests against To, CC, and BCC.
- Confirm staging links use a staging hostname and messages are visibly labeled.
- Check that staging provider events reach the staging handler and test records.
- Send one controlled provider-backed test only when the release needs delivery evidence.
- Include staging sends in the monthly volume forecast and watch for paused sending if credits are exhausted.
We built Volanea to put a transactional email API, campaigns, and automations on one platform, while keeping local capture, render-only validation, and actual sends distinct in your application setup. The right staging design is the one that makes an accidental customer send difficult by default and makes intentional delivery tests traceable.
FAQ
Does a Volanea staging project need a separate AWS Region?
No. Volanea sends over shared Amazon SES infrastructure, and Volanea customers do not manage SES Regions for their projects. Configure application environments, credentials, sender identities, and recipient protections separately. A separate AWS Region is relevant to teams operating their own SES accounts, not a required step for Volanea staging.
Do sk_test_ requests deliver email or use a test inbox?
No. A Volanea key beginning with sk_test_ renders and logs the message but never delivers it. Use it for request validation and template checks in CI. If you need to confirm provider delivery or event handling, use a controlled send to an address your team owns.
When should we move from local capture to a real staging send?
Keep capture for routine template and application changes. Add a real staging send when the test needs to exercise sender configuration, provider acceptance, or delivery-event handling. For example, before enabling a new staging sender, send one message to a controlled QA inbox and confirm the related event reaches the staging handler.
What happens when a plan runs out of email credits?
Sending pauses until the next monthly reset or an upgrade; there is no overage billing. Plan for staging provider sends alongside production and campaigns, and leave room for repeated QA runs. If your forecast is above the available Scale volume, Volanea offers Enterprise for more than 200,000 emails a month with custom monthly volume.
Start free with 1,000 emails a month → https://app.volanea.com/signup