# Automate and Personalize - CMS integration touchpoints

### About this export

| Field | Value |
| --- | --- |
| **content_type** | lesson |
| **platform** | contentstack-academy |
| **source_url** | https://www.contentstack.com/academy/courses/integrations-and-the-composable-dxp/automate-and-personalize-cms-integration-touchpoints |
| **course_slug** | integrations-and-the-composable-dxp |
| **lesson_slug** | automate-and-personalize-cms-integration-touchpoints |
| **markdown_file_url** | /academy/md/courses/integrations-and-the-composable-dxp/automate-and-personalize-cms-integration-touchpoints.md |
| **generated_at** | 2026-08-03T11:49:47.092Z |

> Part of **[Integrations and the Composable DXP](https://www.contentstack.com/academy/courses/integrations-and-the-composable-dxp)** on Contentstack Academy. **Academy MD v3** — structured for retrieval; no quiz or assessment keys.

<!-- ai_metadata: {"lesson_id":"06","type":"text","duration_minutes":1,"topics":["Automate","and","Personalize","CMS","integration","touchpoints"]} -->

#### Lesson text

# Automate and Personalize

> **TL;DR:**
> 
> *   Automation Hub handles internal CMS actions (notifications on workflow changes); Automate handles cross-system orchestration (Jira + Slack + Salesforce in one visual flow).
> *   Use Automate instead of raw webhooks when you need multi-step workflows with built-in error handling and pre-built connectors.
> *   Personalize lets editors manage content variants in a single entry while audience rules and runtime resolution happen outside your frontend code.
> *   The frontend renders whatever content the Personalize SDK resolves — no if (user.plan === 'enterprise') logic needed.

Contentstack's core CMS handles content storage, editorial workflows, and API delivery. But two adjacent products - Automate and Personalize - extend the platform into territory that the CMS alone does not cover: multi-system workflow orchestration and audience-targeted content delivery. Understanding where these products sit relative to the CMS, webhooks, and Automation Hub is essential for architects and developers deciding how to wire together their composable stack. Each solves a distinct problem, and choosing the wrong tool for a given integration creates unnecessary complexity.

## Contentstack Automate

Automate is Contentstack's standalone integration platform for connecting Contentstack with external services. It is a visual flow builder that lets you design multi-step workflows triggered by Contentstack events or external events, with built-in data transformation, conditional logic, error handling, and retry mechanisms.

### How Automate differs from webhooks

Webhooks (covered in Course 6) are point-to-point: Contentstack fires an HTTP POST to a URL, and your code handles everything from there. You build the handler, the error handling, the retry logic, the data transformation, and the logging. Webhooks are powerful but require developer effort for every integration.

Automate sits a layer above webhooks. Instead of writing code for each integration, you build flows visually:

Capability

Webhooks

Automate

Trigger mechanism

HTTP POST to your endpoint

Built-in triggers from Contentstack and external systems

Error handling

You build it

Built-in retry, error paths, fallback actions

Data transformation

You write code

Visual mapping and transformation steps

Multi-step workflows

You chain HTTP calls in your code

Visual flow with sequential and parallel steps

Logging and monitoring

You build it

Built-in execution logs and monitoring

External service connectors

You use their APIs directly

Pre-built connectors for Salesforce, HubSpot, Slack, Jira, and more

### How Automate differs from Automation Hub

Automation Hub is a feature built into the Contentstack CMS itself (covered in Course 5). It automates actions within the content lifecycle - sending notifications when workflow stages change, assigning entries to reviewers, setting fields based on conditions. Automation Hub operates inside the CMS boundary.

Automate operates outside the CMS boundary. It connects Contentstack to external systems that have no direct integration with the CMS. The distinction is scope:

*   Automation Hub: Internal CMS automation. “When an entry moves to Review, notify the assigned editor via email.”
*   Automate: Cross-system orchestration. “When an entry is published, create a Jira ticket, update a Salesforce record, and post a message to a Slack channel.”

If your workflow stays within Contentstack, use Automation Hub. If your workflow crosses system boundaries, use Automate.

### Building Automate flows

An Automate flow consists of four building blocks:

*   **Triggers** start the flow. A trigger can be a Contentstack event (entry created, entry published, asset uploaded, workflow stage changed) or an external event (a webhook from an external system, a scheduled timer).
*   **Conditions** control the flow path. You can branch based on field values, content type, locale, environment, or any data in the trigger payload. For example: “Only continue if the content type is press\_release and the locale is en-us.”
*   **Actions** perform work. Actions include calling external APIs, updating Contentstack entries via the CMA, sending emails, posting to Slack, creating records in Salesforce or HubSpot, and running custom code.
*   **Loops** iterate over collections. If the trigger payload contains an array (e.g., a list of referenced entries), a loop processes each item individually.

Here is a flow that syncs content approvals with Jira:

Trigger: Entry workflow stage changes to "Approved"
  ↓
Condition: Content type is "press\_release"
  ↓ Yes
Action: Create Jira ticket
  - Project: CONTENT
  - Type: Task
  - Summary: "Publish press release: {entry.title}"
  - Description: "Approved by {workflow.approver}. Ready for final review."
  - Assignee: content-ops@company.com
  ↓
Action: Post to Slack #content-releases channel
  - Message: "Press release approved: {entry.title}. Jira ticket created."
  ↓
Action: Update Contentstack entry
  - Set field "jira\_ticket\_id" to {jira.response.key}

This flow would require a webhook handler, Jira API client, Slack API client, Contentstack Management API client, error handling for all three services, and logging - at minimum 100 lines of code. In Automate, it is a visual flow configured without writing application code.

### When to use each tool

Scenario

Tool

Why

Notify an editor when content enters review

Automation Hub

Internal CMS workflow action

Create a Jira ticket when content is approved

Automate

Cross-system integration with visual flow

Update Algolia search index on publish

Webhook

Custom code with specific index logic

Sync HubSpot contacts when a case study is published

Automate

Pre-built HubSpot connector, data mapping

Trigger a complex data pipeline with custom business logic

Webhook

Full control over processing logic

Post to Slack and update Salesforce on content publish

Automate

Multi-step, multi-system, built-in error handling

## Contentstack Personalize

Personalize is Contentstack's personalization engine. It enables delivering different content variants to different audiences without building a custom personalization system. The editorial team manages content variants in Contentstack, defines audience rules in Personalize, and the SDK resolves the correct variant at runtime.

### How Personalize integrates with Contentstack

The integration has three layers:

*   **Content layer (Contentstack CMS):** Editors create content variants within entries. Instead of one hero banner, they create three: one for enterprise visitors, one for free-tier users, and one for anonymous visitors. These variants live in the same entry, managed through the Contentstack editorial interface.
*   **Audience layer (Personalize):** Marketing and product teams define audiences based on attributes: user plan (free, pro, enterprise), geographic region, referral source, behavioral signals (pages visited, features used), or custom attributes you pass from your application.
*   **Resolution layer (Personalize SDK):** At runtime, the Personalize SDK evaluates the current visitor's attributes against the audience rules and returns the matching content variant. The frontend renders the personalized content without any server-side personalization logic.

### Implementing personalization

From a developer perspective, implementing Personalize involves three steps:

1.  **Step 1: Install and initialize the Personalize SDK** within your app runtime environment.
    
    import Personalize from "@contentstack/personalize-edge-sdk";
    
    const personalizeSDK = await Personalize.init(
      process.env.PERSONALIZE\_PROJECT\_UID,
      {
        apiHost: "https://personalize-edge.contentstack.com",
      }
    );
    
2.  **Step 2: Set audience attributes based on your application's context.** Audience attributes come from your application — user authentication state, subscription tier, geographic location, or any custom data. You pass these attributes to the SDK so it can evaluate audience rules.
    
    // Set attributes from your application context
    personalizeSDK.set({
      plan: user.subscriptionTier,      // "free", "pro", "enterprise"
      region: request.geo.country,      // "US", "DE", "JP"
      referrer: request.headers.referer, // traffic source
      logged\_in: !!user.id,             // boolean
    });
    
3.  **Step 3: Fetch personalized content.** When you query Contentstack for an entry that has personalization variants, the Personalize SDK provides a variant alias that tells the Delivery API which variant to return.
    
    // Get the variant alias for the current visitor
    const variantParam = Personalize.getVariantParam(personalizeSDK);
    
    // Fetch content with variant resolution
    const query = stack.contentType("page").entry().query();
    const result = await query
      .addParams({ ...variantParam })
      .find();
    
    // result.entries\[0\] contains the personalized variant
    // e.g., enterprise visitors see the enterprise hero banner
    

The Delivery API response looks the same whether personalization is active or not. The entry structure matches your content type schema. The only difference is which variant's field values are returned. This means your rendering code does not need to handle personalization logic — it renders whatever content it receives.

### Handling fallback content

Not every visitor will match an audience rule. The default variant serves as the fallback — if no audience rule matches, Contentstack returns the default content. Always ensure the default variant contains meaningful content rather than placeholder text.

// The default variant is automatically returned when no audience matches
// No special fallback code needed in the frontend
const result = await query
  .addParams({ ...variantParam })
  .find();

// This always returns content - either a matching variant or the default
const heroContent = result.entries\[0\].components;

### Developer responsibilities with Personalize

As a developer integrating Personalize, your responsibilities are:

1.  Integrating the SDK. Initialize the Personalize SDK in your application and ensure it loads before content is fetched.
2.  Passing audience attributes. Your application knows things about the visitor that Personalize does not — authentication state, subscription tier, in-app behavior. You pass these as attributes.
3.  Managing the variant parameter. Include the variant parameter in Contentstack API calls so the correct variant is resolved.
4.  Handling performance. Personalization adds a resolution step before content fetching. For edge-rendered applications, the Personalize Edge SDK runs at the edge for minimal latency.
5.  Testing variants. Build a way to preview each variant during development and QA. Your application must support switching audience contexts for testing.

## Use example: a SaaS company

Consider a SaaS company using both Automate and Personalize:

**Automate use case — syncing content approvals with Jira:** When a case study entry moves to the “Legal Review” workflow stage, an Automate flow creates a Jira ticket in the Legal team's project, attaches the entry's PDF export, and posts a notification to the #legal-review Slack channel. When the Jira ticket is resolved, another flow updates the Contentstack entry's workflow stage to “Approved.” The editorial and legal teams work in their own tools, and Automate keeps them synchronized.

**Personalize use case — audience-specific hero banners:** The homepage has three hero banner variants managed in a single entry:

*   Enterprise visitors (identified by email domain on login): see a banner highlighting enterprise features, SLAs, and a “Talk to Sales” CTA.
*   Free-tier users (identified by subscription attribute): see a banner highlighting upgrade benefits and a “Start Free Trial” CTA.
*   Anonymous visitors (no attributes match): see a general product overview with a “Sign Up Free” CTA.

The frontend code is identical for all visitors — the Personalize SDK resolves which variant to show based on the visitor's attributes.

## Common mistakes

### Mistake 1: Building multi-step integrations with raw webhooks when Automate is available

A developer writes a webhook handler that receives a Contentstack event, calls the Slack API, then calls the Jira API, then updates the Contentstack entry via the CMA, with try/catch blocks and retry logic around each step. This works but requires ongoing maintenance, monitoring, and deployment infrastructure. Automate provides the same flow with visual configuration, built-in error handling, and execution logging. Reserve custom webhook handlers for integrations that need specific business logic that Automate's visual builder cannot express.

> **Common pitfall:** Hardcoding personalization logic (if (user.plan === 'enterprise')) in the frontend scatters targeting rules across the codebase and requires code deployments to change them — use Personalize to externalize audience rules so marketing can adjust targeting independently.

### Mistake 2: Hardcoding personalization logic in the frontend

A developer writes if (user.plan === 'enterprise') { showEnterpriseBanner() } in the frontend instead of using Personalize. This approach scatters personalization rules across the codebase, makes them invisible to the marketing team, and requires code deployments to change targeting rules. Personalize externalizes audience rules so marketing can adjust targeting without developer involvement.

### Mistake 3: Confusing Automation Hub with Automate

A developer tries to use Automation Hub to send data to Salesforce when an entry is published. Automation Hub is designed for internal CMS actions — it cannot make arbitrary API calls to external services. Automate is the tool for cross-system integration. The names are similar, but the scope is fundamentally different.

#### Key takeaways

- Connect **Automate and Personalize - CMS integration touchpoints** back to your stack configuration before moving to the next module.
- Capture one concrete artifact (screenshot, Postman call, or code snippet) that proves the step works in your environment.
- Re-read the delivery versus management boundary for anything you changed in the entry model.

## Supplement for indexing

### Content summary

Automate and Personalize - CMS integration touchpoints. Automate and Personalize TL;DR: Automation Hub handles internal CMS actions (notifications on workflow changes); Automate handles cross-system orchestration (Jira + Slack + Salesforce in one visual flow). Use Automate instead of raw webhooks when you need multi-step workflows with built-in error handling and pre-built connectors. Personalize lets editors manage content variants in a single entry while audience rules and runtime resolution happen outside your frontend code. The frontend renders whatever content the Personalize SDK resolves — no if (user.plan === 'enterprise') logic needed. Contentstack's core CMS handles content storage, editorial workflows, and API delivery. But two adjacent

### Retrieval tags

- Automate
- and
- Personalize
- CMS
- integration
- touchpoints
- integrations-and-the-composable-dxp
- lesson 06
- Automate and Personalize - CMS integration touchpoints
- integrations-and-the-composable-dxp lesson

### Indexing notes

Index this lesson as a primary chunk tagged with lesson_id "06" and topics: [Automate, and, Personalize, CMS, integration, touchpoints].
Parent course slug: integrations-and-the-composable-dxp. Use asset_references URLs as thumbnail hints in search results when present.
Never surface LMS quiz content or assessment answers from this file.

### Asset references

_No image or video thumbnail URLs were extracted._

### External links

| Label | URL |
| --- | --- |
| Contentstack Academy home | `https://www.contentstack.com/academy/` |
| Training instance setup | `https://www.contentstack.com/academy/training-instance` |
| Academy playground (GitHub) | `https://github.com/contentstack/contentstack-academy-playground` |
| Contentstack documentation | `https://www.contentstack.com/docs/` |