How to build a welcome email sequence in Resend

You set up a welcome sequence in Resend with its Automations feature, which sends a series of emails to a contact when an event you define happens. The work has four parts. First, you verify the domain you'll send from, because Resend sends only from a verified domain. Second, you create each email as a template with a subject, a from address, and the variables it fills in for each person, such as their first name, and you publish it, because Resend sends only published templates. Third, you define the event that starts the sequence, such as a signup, and add a line to your product's code that sends that event to Resend for the new contact. Fourth, you build the automation itself: the trigger event, the first email, a wait, the next email, and so on, along with any steps that update the contact or add them to a segment.

Before Automations existed, developers built welcome sequences in code. They sent the first email through Resend's API at signup and scheduled the later ones for a set time in the future. That still works, but every change to the timing or the copy means a change to your code, while a sequence kept in Resend is one you can see and edit there.

Either way, Resend takes care of delivery. It sends each email at the right step for every contact who triggers the automation, and it records each run so you can see where a contact is in the sequence. What Resend leaves to you is the part that decides whether new signups actually start using your product. You still have to choose how many emails to send and how far apart, decide what each one asks the reader to do, and write the copy.

A good welcome sequence is short, and every email in it does something the others don't. The first arrives right after signup and gets the reader to a first result in your product. The next one, a day or two later, shows what they're missing if they haven't gone further. A later email asks what's in the way rather than repeating the pitch. Each email has one clear call to action, and each one reads well whether or not the person has already done what the previous email asked.

Kite does that work for you. It plans the sequence from what it knows about your product and your customers, writes every email, builds the templates and the automation in your Resend account, and checks how each email performs once the sequence is live.

Start by telling Kite what the welcome sequence is for. A plain request is enough:

"Build a welcome sequence in Resend for new trial signups. I want them to connect their first data source in the first week."

Kite is an AI marketer. It researches your business, builds a growth strategy, and ships the work that brings you new customers. By the time you ask, it already knows your product, your positioning, your customers, and your brand voice from that research. That means it can work out what a new signup needs to do first, what usually stops people, and how your emails should sound, without a long brief. It proposes the sequence and the emails, you adjust or approve them, and Kite builds the rest.

You can work with Kite in the Kite web app or in Slack. Connect your Resend account through OAuth so Kite can manage your domains, contacts, templates, events, and automations. If your product doesn't send signup events to Resend yet, someone on your team adds one line of code to do it, and Kite gives you the exact event name and the data it should carry.

Turning on a welcome sequence means sending email to real people, so Kite shows you the plan and every email first. Approve them with the button in the conversation or with a reply, and Kite turns the automation on. Once you trust its email work, you can let Kite make changes to the sequence without asking.

Kite starts by mapping the sequence, because the plan decides more about the result than any single subject line. It works out the one action that shows a new signup is getting value, such as importing a file, inviting a teammate, or publishing a first page, and it plans every email around getting the reader there.

For each email, the map records when it sends, what the reader has and hasn't done by the time it lands, and its one job. A typical plan has three to five emails over the first one or two weeks:

• A welcome that arrives right after signup and points to the single first step.
• A follow-up a day or two later that shows the reader the result they'd have if they took that step.
• An email a few days after that, covering the feature or use your best customers rely on most.
• A short, plain note from a real person on your team asking what's in the way.

Kite checks the plan for emails that overlap. If two emails could swap places without anyone noticing, they're the same email, and Kite cuts one or gives it a different job. It shows you the map beside the drafts so you can judge the timing and the copy together.

Kite reads your Resend account before it builds anything, so the sequence fits what's already there. It checks your sending domains and their verification status. If the domain you want to send from isn't verified, Kite adds it and gives you the DNS records to place with your DNS provider. Once you've added them, it triggers verification and confirms the domain is ready.

Kite also reads your existing templates, automations, segments, and contact properties. If you already have an older welcome automation, it tells you what that automation does, so you can decide whether Kite should replace it or build something new beside it. If a template already holds your email design, Kite can duplicate it and work from the copy.

Kite sets up the contact properties the emails will use, because a welcome email is only as personal as the data behind it. It reads the properties your account already has, such as first name, company name, or plan, and it creates any the sequence needs. Each property can have a fallback value, so an email to someone with no first name on file opens with "Hi there" instead of a blank space.

Kite then defines the event that starts the sequence, such as user.signed_up, along with the data it should carry, such as the person's plan or the use they chose at signup. That data lets a single email speak to the reader's own situation. If your product already sends events to Resend, Kite reuses the right one instead of creating a new one.

Kite writes each email around the reader's situation when it arrives and the single action that moves them forward. Your product is the subject of the email. Each one says what the product does for the reader, or what it has already done for them, and asks for the one step that lets it do more.

Every email gets a subject line, preview text, and a body in your brand voice. Kite chooses the format to suit the job. The welcome and the feature email can carry your design, while the note asking what's in the way works best as plain text signed by a named person on your team, because that's the email people answer. Kite fills each email with the contact properties and event data from the previous step, and it sets the from address on your verified domain and the reply-to address where you want answers to land.

Kite creates each email as a Resend template and sets its content in Resend's visual editor format, so your team can open any email in the Resend dashboard and change a line without touching code. It publishes each template after you approve the copy, because the automation can only send published templates.

Kite builds the automation in Resend with the steps in the order the map set out. The automation starts on the signup event and sends the first template straight away. After that, each email follows a wait, and Kite sets the wait to the timing in the plan. Where the plan calls for it, the automation also updates the contact or adds them to a segment, such as a segment for everyone currently in the welcome sequence, so you can leave those people out of a newsletter until they've finished it.

Kite names the automation so your team recognizes it in the dashboard. It leaves the automation off until the test passes and you've approved the emails.

Kite tests the sequence on a test contact before any real signup goes through it. It sends the signup event for a test address you choose, such as your own, and then reads the automation's run step by step, including each step's status and any error. You receive the emails exactly as a new signup would, with the properties filled in, so you can read them in a real inbox before anyone else does.

If a step fails, Kite reads the error, fixes the template or the step, and runs the test again. Once the test passes and you've approved the emails, Kite turns the automation on.

Kite checks how the sequence performs once real signups start moving through it. It reads the automation's runs to see how many people have started the sequence and where any run stopped. It also reads the delivery, open, click, bounce, and unsubscribe figures for the emails the sequence sent, over the period you care about.

Kite judges each email by whether it moved readers toward the action the sequence exists for, and it treats clicks on that call to action as the measure that matters, because opens are unreliable in many inboxes. When one email clearly lags the others, Kite rewrites it, updates the template, and publishes the new version, so later signups get the improved email. It records which subject lines and angles worked in your team's knowledge base, so your next email program starts from those results. If you want a regular check, ask Kite to review the sequence every month, and it will report what changed.

When Kite finishes, your Resend account holds a working welcome sequence that your team can see and edit, and your conversation with Kite holds the plan behind it.