Marketing Automation in Web Applications: Setup, CDP Integration

A marketer spends two days segmenting a base in Excel, and a week later the data is already outdated. Clients changed their tariff, but emails go to the wrong people. In an online store with a catalog of 5,000 products, this results in a loss of up to 20% of potential sales. Manual segmentation of 5,000 contacts takes 4 hours, which at a marketer's hourly rate of 2,000 rubles costs 8,000 rubles per campaign. Marketing automation via a web application eliminates the problem — every user action (registration, browsing, purchase) becomes an event that triggers personalized scenarios. After system setup, segmentation takes 15 minutes, and conversion in deferred chains grows by 25–30% per quarter. We have configured such systems for e-commerce and SaaS projects: average revenue increase from repeat sales is 25% over 3 months, and unsubscribe rates drop by 15-20%. Experience: 5+ years, over 30 implementations.

Technical Challenges and Their Solutions

Disparate Data

CRM, email service, analytics — each stores its own piece of the profile. Without a unified CDP, building cross-channel attribution is impossible. The result — emails go to the wrong segments.

Complex Chains

Abandoned cart requires checking whether the customer made a purchase between deferred emails. Manual escalation leads to spam and unsubscribes.

Lack of A/B Testing

You cannot know which email subject line increases conversion if randomization is not built into automation.

How to Avoid Data Loss in Chains?

The key is a transactional event broker (Kafka, Redis Streams). It guarantees at-least-once delivery of each event, preserves order, and allows replaying failures. Example: in the abandoned cart purchase check, we use idempotency — the order.placed event is processed only once, even if a duplicate arrives.

System Architecture and Tools

Architecture

Website (events)          Event Broker      Automation
─────────────────         ───────────────    ──────────────
Registration ─────────►  Kafka/Redis    ──► Email chains
Page view ───────────►  Stream         ──► Push notifications
Add to cart                │              ──► SMS
Purchase                   │              ──► Segmentation
Unsubscribe                ▼
                    CDP (Customer
                    Data Platform)

Tool Selection

Customer.io is 2x faster to set up for small businesses compared to Segment, while Kafka is better for high-load projects.

Implementing Tracking and Segmentation

Event Tracking

// analytics.ts — unified event tracking
class MarketingTracker {
  constructor(
    private customerIo: CustomerIO,
    private posthog: PostHog
  ) {}

  async track(userId: string, event: string, properties: Record<string, unknown>) {
    // Send to Customer.io for automation
    await this.customerIo.track({
      id: userId,
      name: event,
      data: properties
    });

    // Send to PostHog for analytics
    this.posthog.capture({
      distinctId: userId,
      event,
      properties
    });
  }

  async identify(userId: string, traits: UserTraits) {
    await this.customerIo.identify({
      id: userId,
      ...traits,
      last_seen: new Date().toISOString()
    });
  }
}

// Usage in event handler
await tracker.track(userId, 'checkout_started', {
  cart_value: cart.total,
  items_count: cart.items.length,
  currency: 'RUB'
});

await tracker.track(userId, 'page_viewed', {
  page_name: 'pricing',
  plan_viewed: 'pro'
});

Segmentation via Customer.io

// Create segment via API
const segment = await customerio.createSegment({
  name: 'High-Intent Pro Users',
  filter: {
    and: [
      { attribute: { field: 'plan', operator: 'eq', value: 'free' } },
      { event: { name: 'pricing_viewed', timeframe: { days: 7 }, count: { min: 2 } } },
      { attribute: { field: 'total_orders', operator: 'gte', value: 1 } }
    ]
  }
});

Automated Chain: Abandoned Cart

[Event: checkout_started]
         │
[Wait 1 hour]
         │
[Check: was there a purchase?]
    │             │
   Yes           No
    │             │
[Exit]     [Email: "You forgot your cart"]
                  │
           [Wait 24 hours]
                  │
           [Check: purchase?]
                  │
                 No
                  │
           [Email: 10% discount]
                  │
           [Wait 48 hours]
                  │
                 No
                  │
           [Exit chain]

Why CDP Is the Foundation for Personalization?

CDP (Customer Data Platform) collects all events into a unified profile: views, purchases, support inquiries. Without a CDP, emails will be irrelevant: a customer bought a product, but receives an abandoned cart reminder for the same product. We help choose a CDP: for small businesses, Customer.io is suitable; for enterprise, Segment or mParticle.

How to Integrate CDP into an Existing Web Application?

CDP integration begins with setting up event tracking. You need to define key events (registration, page view, add to cart, purchase) and send them to the CDP via API or SDK. To do this, we install a client-side JavaScript SDK and a server-side HTTP client. The typical pattern: all events are duplicated to the CDP and the main database. This ensures no action is lost, even if the CDP is temporarily unavailable.

Why Implement A/B Testing in Chains?

Without A/B tests, you are flying blind. For example, a welcome email with different subject lines yields different CTR. We set up randomized experiments directly in Customer.io or PostHog. The sample size must be at least 1,000 contacts for statistical significance. Result: conversion to target action increases by 20-40% by selecting the best variant.

Implementation Process

What Is Included in the Work

• Comprehensive audit of marketing channels and customer data
• Design of event model and segments
• Tracking integration into the web application (with documentation provided)
• Setup of automated chains (welcome, abandoned cart, post-purchase, etc.)
• A/B testing of email hypotheses
• UTM tagging setup via link templates
• Training your team in the automation interface (1–2 days)
• Support during the first month after launch

Timelines and Cost

Basic automation (welcome chain + abandoned cart) — 1 week. Full set of chains with segmentation and A/B tests — 2–4 weeks. Cost is calculated individually after the audit.

Common Automation Mistakes

• Mismatch of data types in events (string instead of number) — breaks segmentation.
• Lack of a unique customer identifier — events are not linked to a profile.
• Incorrect timezone handling — emails arrive at 3 AM.

Contact us for an audit of your project. Get a consultation on marketing automation — we will assess how much time and budget you can save. Request an audit today — we will offer the optimal solution.

Email Campaign Integration: Why Does It Often Break?

We’ve observed that a trigger email sent 10 minutes after registration converts 4–5 times better than the same email sent after 24 hours. This isn’t a marketing myth—it’s mechanics: while the user is still warm, while they remember the context. But most integrations with email services are built like this: form submits → synchronous HTTP request to API → if the API is slow, the user waits 3 seconds → the email either goes out or doesn’t, nobody knows. In one project, we saw a 30% drop in conversion simply because the email service responded with 504 and Laravel’s queue driver wasn’t configured. Lost emails often hit customers silently – no log, no alert, just a missing order confirmation.

If you’re facing lost emails or spam folder issues, order an audit of your current integration – we’ll find bottlenecks within 2 days.

Providers and Their APIs

Unisender — a Russian provider popular in the SMB segment. REST API, simple. Adding a contact: importContacts, sending a transactional email: sendEmail. Important: for transactional emails (order confirmations, password resets), Unisender Go is a separate service with a different API and separate pricing. Mixing bulk and transactional mailings in one stream is bad for domain reputation. Unisender Go handles up to 1000 requests per second.

SendPulse — provides email, SMS, web push, Viber, and Telegram bots through a unified API. Convenient for projects requiring an omnichannel approach. Automation 360 is a visual chain builder; you can trigger automation via API events. The PHP SDK (sendpulse/rest-api-php-sdk) is maintained but updated irregularly – better to use Guzzle directly.

Mailchimp — a choice for international audiences and marketing teams accustomed to the Mailchimp ecosystem. Transactional email via Mandrill (a subsidiary service). Marketing API v3 for list, tag, and campaign management. Webhooks for opens, clicks, unsubscribes, bounces.

SMS. For Russia: SMSCenter, MTS Exolve, Devino Telecom, SMS Aero. Their APIs are similar: a send method with phone, message, sender parameters (sender name must be registered separately with the operator). One nuance: the sender name must be registered through the aggregator with a contract – otherwise SMS won’t be sent on MTS/MegaFon/Beeline networks.

How to Build an Integration That Doesn’t Lose Emails?

Separate Transactional and Marketing Streams

Transactional emails (order confirmations, password resets, delivery status) go through a dedicated sender domain or subdomain tx.example.com. Marketing campaigns go through mail.example.com or news.example.com. If a marketing campaign receives many spam complaints, it should not affect the reputation of the transactional stream. According to SendGrid documentation, transactional messages should be sent through a dedicated IP pool to prevent cross-contamination.

Queue and Retry

Any call to the email API goes through a queue (Laravel Queue, Bull, Celery). If Unisender returns a 503, the job retries after 5 minutes, then 15, then 60. After 5 failed attempts, it goes to a dead letter queue with an alert. The user already received their 200 OK and knows nothing about the issue. This approach reduces bounce rate on projects to 0.5%.

Example Laravel job:

public function handle(): void
{
    try {
        $response = Http::post(config('services.unisender.email_url'), $this->params);
        if ($response->failed()) {
            $this->release(300); // retry after 5 min
        }
    } catch (\Throwable $e) {
        $this->release(300);
    }
}

Templates

We store templates in code (Blade, Twig, React Email), not in the provider’s interface. Reasons: versioning via Git, browser preview without sending, testability. For complex templates with dynamic content — react-email with export to HTML via @react-email/render.

Validation and Consent

Before adding a contact to a list — double opt-in (confirmation email). Store the confirmation timestamp in your own database. Upon unsubscription — synchronously unsubscribe both at the provider and in your database. Ignoring webhook unsubscriptions is a direct path to account suspension at the provider. All processes comply with Федеральный закон № 152-ФЗ «О персональных данных».

Deliverability Monitoring and DKIM Setup

Connect provider webhooks for events: bounce (hard and soft), spam_complaint, unsubscribe. Hard bounce — immediately mark the email as invalid in your database, stop sending. Soft bounce 3 times in a row — same. Metrics: open rate, click rate, bounce rate, unsubscribe rate — review at least once a week. Our certified engineers configure alerts in Grafana/Prometheus.

DKIM configuration steps:

1. Generate a key pair (e.g., openssl genrsa -out private.key 2048).
2. Publish the public key in DNS as a TXT record for the selector (e.g., mail._domainkey.tx.example.com).
3. Provide the selector to the provider (SendGrid, Mailgun, Unisender).
4. Verify with dig TXT mail._domainkey.tx.example.com.

SPF, DKIM, DMARC must be configured separately for each stream. We use subdomains with different DNS records.

Why Is It Important to Separate Streams?

If you send a marketing campaign from the same domain as transactional emails and receive spam complaints, you risk getting the domain blocked — and users will stop receiving even order confirmations. SPF, DKIM, DMARC (Sender Policy Framework, DomainKeys Identified Mail, Domain‑based Message Authentication, Reporting and Conformance) must be configured separately for each stream. In one project, a marketing blast with 12% spam complaints blocked the transactional domain for 48 hours — we had to re‑authenticate with Google and Yandex.

What Does the Integration Scope Include?

• Audit of current communication streams and domain reputation (SPF, DKIM, DMARC)
• Provider and schema selection: transactional vs marketing traffic
• Configuration of SPF, DKIM, DMARC DNS records
• Development of email templates (HTML + dynamic content)
• Backend integration via queues and API
• Webhook setup for deliverability and complaints
• Operations documentation and team training
• Deliverability guarantee and post‑launch support

We deliver production‑ready documentation, access to monitoring dashboards, and a handover session with your engineers. Our certified engineers provide a 30‑day post‑launch health check guarantee.

Timelines and Cost

Cost is calculated individually after audit. We provide turnkey service: from analysis to production monitoring. Contact us for a free engineer consultation — we’ll evaluate your project and give accurate timelines. Over 7 years of experience in email service integration, 50+ projects implemented. Order a free audit of your current integration and receive a report with recommendations and estimated savings.