Sequences

Build automated email workflows that respond to subscriber behavior

Sequences (Automations)

Sequences are automated email workflows that send the right message at the right time based on subscriber actions, tags, segments, or events. They’re the heart of marketing automation in Sequenzy.

What Are Sequences?

A sequence is a series of connected steps that execute automatically:

┌─────────────────┐
│    TRIGGER      │  ← Starts the sequence
│ (Tag or Event)  │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│     ACTION      │  ← Does something
│  (Send Email)   │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│     LOGIC       │  ← Controls flow
│ (Wait 3 days)   │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│     ACTION      │
│ (Send Email #2) │
└─────────────────┘

Sequence Components

Triggers

Triggers define when a sequence starts. Each sequence has exactly one trigger.

Trigger Type	Description	Use Case
contact_added	Subscriber added to list	Welcome sequence
tag_added	Tag applied to subscriber	Customer onboarding
segment_entered	Subscriber enters segment	Lifecycle automation
event_received	Event triggered via API	Post-purchase flow

Segment-Entered Trigger Behavior

The segment_entered trigger is designed to avoid surprise sends.

• When you activate a sequence, Sequenzy uses the current segment members as a baseline and does not enroll them automatically.
• Only contacts who enter the segment after that baseline are enrolled.
• The segment trigger is evaluated in the background every 15 minutes.
• You can optionally stop active contacts if they later leave the triggering segment.
• If you edit the segment definition or reactivate the sequence later, Sequenzy creates a new baseline instead of backfilling historical matches.

If you want to send the sequence to contacts who are already in the segment, use Enroll Existing Subscribers manually.

Actions

Actions perform operations on the subscriber.

Action Type	Description
Send Email	Send an email from your templates
Update Tags	Add a tag or remove a tag from a subscriber
Update Lists	Add a subscriber to a list or remove them from a list
Webhook	Call an external URL with subscriber data

When you add an Update Tags step in the builder, you choose whether that step should add a tag or remove one. You can change that choice later by editing the step.

When you add an Update Lists step, you choose whether the step should add the subscriber to a list or remove them from one. This is useful for routing contacts into new subscription tracks, suppressing them from a list mid-sequence, or chaining list-triggered sequences together.

Logic Nodes

Logic nodes control the flow of the sequence.

Logic Type	Description
Delay	Wait for a specified time (minutes, hours, days)
Condition	Branch based on a single condition
Branch	Multi-path branching (if/else if/else)
Wait for Event	Pause until an event occurs or timeout

Building Sequences

The Visual Editor

Sequences are built in a visual drag-and-drop editor:

1. Add a trigger - How does the sequence start?
2. Add actions - What should happen?
3. Add logic - When and how should it happen?
4. Connect nodes - Define the flow between steps
5. Activate - Turn on the sequence

Already have subscribers who match your trigger? Use Enroll Existing Subscribers to add them retroactively.

Example: Welcome Sequence

┌─────────────────────┐
│ Trigger: Tag Added  │
│ "new-signup"        │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│ Send: Welcome Email │
│ "Getting Started"   │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│ Delay: 2 days       │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│ Send: Tips Email    │
│ "5 Pro Tips"        │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│ Delay: 3 days       │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│ Send: Feature Email │
│ "Discover Features" │
└─────────────────────┘

Example: Post-Purchase Sequence

┌────────────────────────┐
│ Trigger: Event         │
│ "saas.purchase"        │
└───────────┬────────────┘
            │
            ▼
┌────────────────────────┐
│ Send: Thank You Email  │
└───────────┬────────────┘
            │
            ▼
┌────────────────────────┐
│ Delay: 7 days          │
└───────────┬────────────┘
            │
            ▼
┌────────────────────────┐
│ Wait for Event:        │
│ "feature_activated"    │
│ Timeout: 14 days       │
└───────────┬────────────┘
            │
       ┌────┴────┐
       │         │
  Event Fired  Timeout
       │         │
       ▼         ▼
┌───────────┐ ┌───────────┐
│ Add Tag   │ │ Send Help │
│ "engaged" │ │ Email     │
└───────────┘ └───────────┘

Personalizing Sequence Emails With Event Properties

When a sequence starts from an event trigger, Sequenzy stores that event’s properties on the sequence run. You can use those values in any later email in the same sequence with event. merge tags.

Examples:

• {{event.city}}
• {{event.windMaxSpeed}}
• {{event.alert.maxSpeed}}

This is useful when the event contains context that should stay stable across multiple emails, such as a weather alert region, the purchased plan, or the trial length that started the flow.

How It Works

• The event snapshot is stored on the automation run when the subscriber enters the sequence
• Every later email in that same sequence reads from the same stored snapshot
• A later event for the same subscriber does not overwrite earlier sequence runs

That means your second or third email still references the original event data that enrolled the subscriber.

Example

If your app sends:

{
  "event": "weather.wind_alert",
  "properties": {
    "city": "Tel Aviv",
    "windMaxSpeed": 75,
    "duration": {
      "hours": 6
    }
  }
}

You can write:

• Subject: Wind alert for {{event.city}}
• Body: Winds may reach {{event.windMaxSpeed}} km/h for {{event.duration.hours}} hours.

Defaults

You can use fallback values if a property may be missing:

• {{event.city|your area}}
• {{event.duration.hours|a few}}

Condition Types

Conditions let you branch sequences based on subscriber data.

Tag Conditions

Condition: has_tag "customer"
  ├─ Yes → Send upsell email
  └─ No  → Send conversion email

List Conditions

Condition: in_list "VIP Customers"
  ├─ Yes → Send exclusive offer
  └─ No  → Send standard offer

Field Conditions

Condition: field_equals "plan" "enterprise"
  ├─ Yes → Assign to sales team
  └─ No  → Send self-serve resources

Available Operators

Operator	Description	Example
has_tag	Subscriber has tag	has_tag "customer"
in_list	Subscriber in list	in_list "Newsletter"
field_equals	Field exact match	field_equals "plan" "pro"
field_contains	Field contains string	field_contains "company" "Inc"
field_greater_than	Numeric comparison	field_greater_than "mrr" 100
field_less_than	Numeric comparison	field_less_than "age" 30

Wait for Event

The “Wait for Event” node pauses execution until a specific event occurs.

Wait Types

Wait Type	Description
email_opened	Wait for previous email to be opened
email_clicked	Wait for link click in previous email
email_replied	Wait for reply to previous email
event_received	Wait for a custom event by name

Timeout Behavior

Every wait has a timeout. When the timeout expires:

• The sequence continues down the “timeout” path
• You can send follow-up emails or take alternative actions

┌─────────────────────┐
│ Wait for Event:     │
│ "demo_scheduled"    │
│ Timeout: 5 days     │
└──────────┬──────────┘
           │
      ┌────┴────┐
      │         │
   Event    Timeout
      │         │
      ▼         ▼
┌──────────┐ ┌──────────┐
│ Send     │ │ Send     │
│ Prep     │ │ Follow   │
│ Email    │ │ Up Email │
└──────────┘ └──────────┘

Branching

Simple Condition (2 paths)

┌─────────────────────┐
│ Condition:          │
│ has_tag "customer"  │
└──────────┬──────────┘
           │
      ┌────┴────┐
      │         │
     Yes        No
      │         │
      ▼         ▼
┌──────────┐ ┌──────────┐
│ Upsell   │ │ Convert  │
│ Email    │ │ Email    │
└──────────┘ └──────────┘

Multi-Branch (3+ paths)

┌─────────────────────────────┐
│ Branch:                     │
│ ├─ plan = "enterprise"      │
│ ├─ plan = "pro"             │
│ └─ else (default)           │
└─────────────┬───────────────┘
              │
     ┌────────┼────────┐
     │        │        │
 Enterprise  Pro    Default
     │        │        │
     ▼        ▼        ▼
┌────────┐ ┌────────┐ ┌────────┐
│ VIP    │ │ Pro    │ │ Basic  │
│ Email  │ │ Email  │ │ Email  │
└────────┘ └────────┘ └────────┘

Sequence States

State	Description
draft	Being edited, not active
active	Running, processing subscribers
paused	Temporarily stopped
archived	No longer in use

Tokens (Subscriber Journeys)

When a subscriber enters a sequence, a “token” tracks their progress:

{
  "subscriberId": "sub_abc123",
  "automationId": "auto_xyz",
  "currentNode": "node_456",
  "status": "active",
  "context": {
    "entryPoint": "tag_added",
    "emailsSent": 2,
    "waitingFor": "email_opened"
  }
}

Token States

State	Description
active	Currently progressing through sequence
waiting	Paused at a wait/delay node
completed	Finished all steps
failed	Error occurred
cancelled	Manually stopped

Real-World Sequence Examples

SaaS Trial to Paid

Trigger: Event "saas.trial_started"
    │
    ▼
┌───────────────────┐
│ Send: Trial       │
│ Welcome Email     │
└─────────┬─────────┘
          │
          ▼
┌───────────────────┐
│ Wait: 3 days      │
└─────────┬─────────┘
          │
          ▼
┌───────────────────┐
│ Send: Tips Email  │
│ "Get the Most..." │
└─────────┬─────────┘
          │
          ▼
┌───────────────────┐
│ Wait: 4 days      │
└─────────┬─────────┘
          │
          ▼
┌───────────────────────┐
│ Condition: has_tag    │
│ "customer"            │
└───────────┬───────────┘
            │
       ┌────┴────┐
       │         │
      Yes        No
       │         │
       ▼         ▼
   (End)    ┌───────────────┐
            │ Send: Last    │
            │ Chance Email  │
            └───────────────┘

E-commerce Abandoned Cart

Trigger: Event "ecommerce.cart_started"
Continue while: Tag "ecommerce.in_cart"
    │
    ▼
┌───────────────────┐
│ Wait: 1 hour      │
└─────────┬─────────┘
          │
          ▼
┌───────────────┐
│ Send: Cart    │
│ Reminder      │
└───────┬───────┘
        │
        ▼
┌───────────────┐
│ Wait: 1 day   │
└───────┬───────┘
        │
        ▼
┌───────────────┐
│ Send: 10% Off │
│ Coupon        │
└───────────────┘

Re-engagement Campaign

Trigger: Tag Added "inactive-30d"
    │
    ▼
┌───────────────────┐
│ Send: We Miss You │
└─────────┬─────────┘
          │
          ▼
┌─────────────────────┐
│ Wait for Event:     │
│ "session_started"   │
│ Timeout: 7 days     │
└─────────┬───────────┘
          │
     ┌────┴────┐
     │         │
   Event    Timeout
     │         │
     ▼         ▼
┌──────────┐ ┌──────────┐
│ Remove   │ │ Send     │
│ Tag      │ │ Special  │
│ inactive │ │ Offer    │
└──────────┘ └────┬─────┘
                  │
                  ▼
             ┌──────────┐
             │ Wait     │
             │ 14 days  │
             └────┬─────┘
                  │
                  ▼
             ┌──────────┐
             │ Add Tag  │
             │ "churned"│
             └──────────┘

Best Practices

1. Start Simple

Begin with 3-5 step sequences before building complex flows:

Trigger → Email → Delay → Email → End

2. Use Tags for State

Track sequence progress with tags:

- "onboarding-started" (at trigger)
- "onboarding-complete" (at end)

3. Set Reasonable Delays

• Welcome emails: immediate to 30 minutes
• Follow-ups: 2-4 days
• Re-engagement: 1-2 weeks

4. Always Have Exit Conditions

Check if the goal is achieved before sending more emails:

Condition: has_tag "customer"
  ├─ Yes → End sequence
  └─ No  → Continue emails

5. Personalize with Conditions

Different paths for different subscribers:

Branch on plan:
  ├─ Enterprise → High-touch content
  ├─ Pro → Feature-focused content
  └─ Free → Conversion content

Related

Tags

Use tags to trigger sequences

Events

Trigger sequences with events

Campaigns

One-time broadcasts vs sequences

Transactional

Immediate emails via API