Product News

Courier Updates

User Experience

Product Management

Integrations

Engineering

Live Streaming

Notifications Landscape

Courier

Tejas Headshot

Tejas Kumthekar

Are you looking for a way to gain a clearer picture of your users and use that insight to improve your communication strategies? We've got some great news for you! Today, we're thrilled to announce an integration between Courier and [Rudderstack](https://www.rudderstack.com/ "Customer data platform for developers"), a customer data platform (CDP) that allows businesses to collect, process, and route customer event data across product, marketing, and analytics tools for better decision-making. 

![Rudderstack Courier data flow](//images.ctfassets.net/z7iqk1q8njt4/21cNA4cs1XUQkN6bUZkyO8/ebd8e69ee53020b4d57d23212aae53c5/Rudderstack_Courier_data_flow.png)

This integration builds on our [recently improved integration with Segment](https://www.courier.com/blog/smarter-customer-engagement-flows-segment-integration/ "Smarter customer engagement flows using Segment and Courier") and will further improve your ability to track your users' actions and take advantage of customer data stored in RudderStack to improve the notification experience for your users.

> Courier makes it easy to trigger notifications based on RudderStack events. We're really excited about this integration because it removes a lot of complexity for engineers and data teams looking to build a notification system.  
>
> __Eric Dodds__, Head of Product Marketing, [RudderStack](https://www.rudderstack.com/)

For those who may not be familiar with RudderStack, it’s a [customer data platform](https://www.rudderstack.com/blog/what-is-a-customer-data-platform/ "What is a Customer Data Platform?") (CDP) that allows businesses to collect, process, and route customer event data across product, marketing and analytics tools for better decision-making. As for Courier, it’s an all-in-one notifications solution that enables development teams to manage communications with their users, from product notifications to marketing messages, through a number of channels, such as email, chat, in-app messages, SMS, and push, all in one place.

So, by integrating Courier with RudderStack, you get the combined benefits of both systems: you can now collect, process, and route your users' interaction data between Courier and different marketing and analytics tools, via RudderStack. This integration can help you gain a clearer picture of your users and use that insight to improve your communication strategies. 

You can also track notification engagement data, such as the percentage of communications that were successfully delivered, opened and read, and on what notification channels. The detailed notification analytics data gives you the potential to create more personalized app experiences for users based on their activity within your product. For example, you could adjust the way a user receives notifications based on their interactions with your product, as well as data from Salesforce, Google Ads, Mailchimp, and other RudderStack sources.
## More about Courier
Courier is an API and web studio that centralizes all product-triggered communications, such as email, chat, in-app messages, SMS, and push notifications. With Courier, businesses can deliver messages to their users using their preferred communication channels, with real-time visibility and tracking for each message. This tracked data within Courier can now be passed to RudderStack!

One of the best things about Courier is that it provides a single, unified interface for developers to manage all communications. This reduces complexity and eliminates the need for developers to manage multiple APIs and libraries to send notifications to various channels. Courier's simple and elegant APIs make it easy for developers to create new notifications and manage messages in a way that doesn’t require additional work for each new notification channel.
## More about RudderStack
RudderStack, as we already mentioned, is an easy-to-use CDP, with a straightforward installation process and intuitive user interface. It doesn’t require any in-depth technical knowledge, making it a popular choice for businesses that want to collect and process customer data without the need for a dedicated development team.

Unlike most other CDPs, RudderStack is open-source, which means that developers can access the source code, modify it to suit their needs, and contribute to the development of the platform. Additionally, RudderStack offers a range of pricing plans, including a free plan, making it accessible to businesses of all sizes. Another great feature of RudderStack is that you can host it in your private cloud infrastructure, giving you even more control over your data.

Unlike most other CDPs, RudderStack is open-source, which means that developers can access the source code, modify it to suit their needs, and contribute to the development of the platform. Additionally, RudderStack offers a range of pricing plans, including a free plan, making it accessible to businesses of all sizes. Another great feature of RudderStack is that you can host it in your private cloud infrastructure, giving you even more control over your data.
## RudderStack’s control plane
The RudderStack platform consists of two main components: the user-facing control plane and the data plane that operates under the hood. In this section, we'll take a closer look at the control plane.

The control plane is the web-based interface that allows you to manage data integrations, monitor data flows, and control user access. It's the place where you can configure and manage your RudderStack accounts, add and remove integrations, and control who can access data.

RudderStack’s control plane also lets you manage your data integrations easily. For instance, you can set up and choose your data destinations and sources, control who can access the data, and monitor the flow of data between the sources and destinations. 

In RudderStack, [sources](https://www.rudderstack.com/docs/sources/overview/ "Sources overview") are platforms or applications from which RudderStack tracks and collects data. A [destination](https://www.rudderstack.com/docs/dashboard-guides/destinations/ "Destinations overview"), on the other hand, is a cloud tool or a platform where you want to send this collected data.

From the control plane, you can also create custom transformations and enrichments to modify the data before it gets sent to the destination. These features provide you with granular control over your data integrations and allow you to create custom data pipelines that fit your specific needs.
## Events — the data sent by Courier
There are two types of user data Courier can now send to RudderStack: message events and audience events.

Message events are all about notification deliverability and user engagement. These events track whether a message was sent, delivered, clicked, and opened. Message events help businesses track notification usage data, including successful deliveries, opens, clicks, and the channels through which messages are sent. This data can help businesses create custom user journeys that are tailored to users' communication preferences, improving the overall user experience.

Audience events, on the other hand, make use of Courier's dynamically defined user groups, known as audiences. Audiences give you more flexibility than static lists. For instance, you can define an audience as a set of users with the title “Software Engineer.” You can even take this one step further and define more niche audiences by specifying that the user also has listed, for example, TypeScript as one of their favorite programming languages. 

Audience events allow you to track when people join or leave these pre-defined groups based on changes in user characteristics, allowing for better data collection and therefore improved end user experience. For example, an audience event would be triggered if someone changed their job title to “Software Engineer” or if they changed it from “Software Engineer” to something else. This gives you control over the type and amount of notifications specific users receive, improving their overall experience.
## Using this new data
When your events have been loaded in RudderStack, you can use different aggregate views to study them, or you can forward them to an analytics destination like Looker or Tableau. This integration enables you to perform analytics on your notification data, giving you powerful insights about how your users interact with your product, and create even more enjoyable notification experiences. 

You can also automatically update information in Courier from your product or from other software tools via RudderStack. For example, if a user changes their email address in your web app, you can propagate that information into the user’s profile in Courier without the need to add a separate Courier API request.
## What are you waiting for?
Whether you're new to RudderStack or an existing user, integrating Courier is a straightforward process. To enable the integration, add Courier as a source and/or destination. Adding Courier as a destination is as simple as specifying Courier as a "destination" in your RudderStack dashboard. Just navigate to ‘[directory](https://app.rudderstack.com/directory "Rudderstack Integrations Directory")’, go to the `destinations tab` and search for Courier.

For more detailed information on how to implement courier as a source or destination, and help getting started with the RudderStack and Courier integration, visit our [documentation](https://www.courier.com/docs/external-integrations/rudderstack/ "Courier<>Rudderstack Documentation") and follow the steps outlined there. This will start the flow of data and can start giving insights straight away, helping you to improve your user experience and helping you make better product decisions.

Courier is a notification service that centralizes all of your templates and messaging channels in one place which increases visibility and reduces engineering time. 

Start Routing Notifications Today!

Integrate Rudderstack and Courier to trigger notifications from Rudderstack events

rudderstack-courier-integration

A new integration between Courier and RudderStack, a customer data platform (CDP) that allows businesses to collect, process, and route customer event data.

New RudderStack integration: Create actionable data Insights

Rudderstack integration thumbnail

New RudderStack integration: Create actionable data insights

donnie-headshot

Donnie Wang

Having a clear idea how your users interact with your app — when they log in, which features they engage with, or which notifications they click on  — can help you design a better experience and ultimately increase user engagement. But retracing your users’ steps across various integrations is a complex task. Customer data platforms (CDPs) like Segment seek to achieve it by aggregating event data from multiple sources in one centralized location. This helps businesses gain a clearer picture of their users, and use that insight to individualize the app experience. 

How an app communicates with its users is key. Whether you’re using web and mobile push notifications, an in-app inbox, automated email and SMS messages, or Slack notifications: all of that can have a huge impact on how the app experience is perceived by your users. That’s why it’s so vital to track notification usage data in your CDP. 

Today, we’re excited to announce that teams using Segment can now ingest notification usage data from [Courier](https://www.courier.com/), so that it can serve as a basis for new insights. Which communications were successfully delivered? Which ones were opened and read? On what channels? These types of events generated in Courier can now be used to create custom user journeys.

This step completes the integration of the two services: previously, [Segment was available as a data destination in Courier](https://www.courier.com/blog/courier-segment-integration-product-notifications/). Now that the integration has come full circle, let’s have a look at how your organization can benefit from combining the two tools.

> Courier’s Segment integration really sealed the deal. You can simply get more understanding of the customer journey and the actions and the events that are being triggered along the usage of the product. 
> 
> __Pierre-Camille Hamana__, CEO & Founder, [Hospitable](https://hospitable.com/)

## Marrying Courier and Segment
In case you haven’t heard of us before, Courier is a notification platform that lets you develop, scale and manage multi-channel notifications for your application. Combining powerful API primitives with a no-code UI for designing and monitoring notification flows, Courier makes it far easier to build notification experiences that work in sync with your application UX than if you created a complex notification infrastructure from scratch.

[Segment](https://segment.com/) is a popular customer data platform (CDP) that lets you collect data generated by your users in various locations and assemble it in one place. This gives you a more complete picture of your users, allowing you to target them in a smarter and more personalized way. If your organization uses different tools to track and store user interactions, then you’re likely using a CDP like Segment. 

In Segment, your users’ interactions are stored as “events,” complete with metadata that you define in advance. Events can be associated with a user’s ID, or be stored anonymously, depending on permissions. You can then retrieve them for further data analysis, like aggregating and partitioning events according to different criteria, depending on the questions you’re trying to answer. 

For instance, you could be looking at general user engagement with a specific notification, announcing a new product feature. Or you could use your event data to understand how a specific group of people — for instance, 25- to 35-year-olds located in Southern Africa — engaged with your notification within a particular timespan; say, within 24 hours of sending the notification. Such information can now easily be obtained, thanks to the two-way integration of Courier and Segment. 
![Segment Integration feature launch post 4](//images.ctfassets.net/z7iqk1q8njt4/5VhdLXpzJCZbKQCmBqwovg/10a0bd7a8d4e0a738aec3630e9cb2490/Segment_Integration__feature_launch_post_4.png)

Sharing data between Courier and Segment benefits both the engineer looking to create a more organic notification experience for their users and the data analyst who wants insights into how users are interacting with a given product. The Courier Segment integration enables you to reap the full benefit of combining both tools.

## Courier as a destination for Segment events
Many product teams already use Segment and Courier today. For the last two years, the [Courier destination](https://segment.com/docs/connections/destinations/catalog/courier/) in Segment has allowed companies like [Hospitable](https://www.courier.com/customers/hospitable/) to create impactful multi-channel notification experiences. Event data tracked in Segment would flow into Courier, and trigger pre-configured notifications.

For example, you could respond to a user’s actions — such as the purchase of a particular product or a password reset request — by sending out a particular notification via an in-app inbox message, a push notification, or an email. 
![Segment Integration feature launch post 2](//images.ctfassets.net/z7iqk1q8njt4/bPnZssbRACA03zzLli51D/0c681f4d2cec11a7ccca298c922d5ac5/Segment_Integration__feature_launch_post_2.png)

By combining Segment event data with Courier’s notification-sending abilities, teams can design a notification experience that feels personalized and tailored to the user’s product journey — with almost no engineering effort.
![Segment Destination Setup Gif](//images.ctfassets.net/z7iqk1q8njt4/lZgPWxlYvMQbDrAID94zK/408e0bcdba90eef8dde093f9e199f374/segment_destination_setup.gif)

## Understand your users more fully through notification data
However, when you send out a notification to your users, that in turn creates new event data. Did the user click on your notification within a certain time span? How many notifications were not delivered? What percentage of users unsubscribed? All that is extremely valuable information when trying to form a full picture of how your users engage with your product.
![Segment Integration feature launch post 3](//images.ctfassets.net/z7iqk1q8njt4/3Rl9EZ1dgO3WoVFZUseljY/933879ca6699ca43455988d8e419ad38/Segment_Integration__feature_launch_post_3.png)

By integrating [Courier as a source of events in Segment](https://www.courier.com/docs/guides/tutorials/how-to-send-notifications-with-segment/#courier-as-a-segment-source), you can now make the most of that valuable data. Simply import notification events into Segment, where you can combine them with data from other websites and apps. 
![courier-source-in-segment](//images.ctfassets.net/z7iqk1q8njt4/49pVRp9VvcGMrV5lmpGXCc/42de4a35ada7b09e9849d1f2d44edf30/segment_courier_source_setup.gif)

Once connected, Courier can send two types of user data to Segment: message events and audience events.

### Message events
Message events are related to deliverability of your notifications, as well as how your users engage with them. Whether a message was sent, delivered, clicked, and opened: all of that can be observed via message events. 

By combining these events with other data, you can gain valuable insights. Let’s say, for example, that users in a certain region seem to engage less with messages that are sent at a specific time of day. You can now experiment with different sending times, and see whether that increases metrics such as the open rate. Or perhaps the notification title doesn’t work as well for certain audiences? You can tweak it and see if that improves user engagement.

### Audience events
[Audiences](https://www.courier.com/docs/reference/audiences/) are Courier’s dynamically defined user groups, which are more flexible than static lists. For instance, you can define an audience that is located in the US. When a user from that audience travels abroad and their profile is updated, they will automatically be removed from the US audience based on their updated location. That will, for example, affect the times at which they receive a message — so you can make sure that nobody is woken up by an email trying to sell them a product, or similar disruptive behavior.

Once your message and audience events are in Segment, you can aggregate and view them to gain insights, or route them to an analytics destination like Tableau or Looker. Thanks to the Segment integration, you’re now able to perform [analytics on your notification data](https://www.courier.com/blog/pm-guide-omnichannel-analytics/), and gain powerful insights about your users’ journey. Having a clearer understanding of how your users engage with your messages will help you create even more delightful notification experiences.

## Get started
The Courier Segment integration is available now to all users. Read the [docs](https://www.courier.com/docs/guides/tutorials/how-to-send-notifications-with-segment/) to get started. For those already using Courier as a destination for Segment events, setting up Courier as a data source is simple. You can [add Courier as a data source](https://www.courier.com/docs/guides/tutorials/how-to-send-notifications-with-segment/#courier-as-a-segment-source) by wiring up your Segment write key.

By making Courier available as a source in Segment, we’re getting one step closer to a full understanding of your users’ actions and motivations. Try it out today!

segment-launch-header

Courier can now be both a destination for Segment events and a source of events for further data-based actions in the Segment CDP. 

Smarter customer engagement flows with Courier’s new Segment integration

segment-launch-thumbnail

shreya-headshot

Shreya Gupta

## Before Starting
GitHub Repository: [https://github.com/shreythecray/infiltration](https://github.com/shreythecray/infiltration)

**The hackathon ends soon,** and we are giving away over $1K in prizes! Join us in building a cool project and winning any of the following prizes. 🏆

- **Courier Hacks 1st Place:** Top submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive $1000 via Zelle or PayPal.
- **Courier Hacks 2nd Place:** 2nd Place submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive the Apple AirPods Pro.
- **Public Favorite:** Public favorite winner will receive a Keychron Keyboard.
- **Runners-Up:** Runners-up submissions will receive a Hydro Flask.

Additionally, everyone who submits a project successfully integrating the Courier API will receive a $20 Amazon gift card! Submissions close on **September 28th**. Register now to submit this project for a chance to win some cool prizes.

Register for the Hackathon: [https://courier-hacks.devpost.com/](https://courier-hacks.devpost.com/)

Not sure where to start? In this tutorial, we will create a Discord bot that sends daily automated messages encrypted in Morse code with Node.js and the Courier API.

## What is Going On?

### Recap
We are secret agents, and we previously built an application to send secret messages encrypted in Morse code to communicate with our spy network. [Learn more >](https://www.courier.com/blog/hackathon-courier-api-nodejs/)

Last time, headquarters told us that one of our spies had leaked sensitive, top-secret information to our enemies, so we built a lie detector that alerted our spy network when we identified the mole. We used Azure's Cognitive Services to perform facial recognition on everyone on our team and Courier to broadcast the identity of the mole to our spy network. [Learn more >](https://www.courier.com/blog/serverless-lie-detector-facial-recognition/)

### What’s Next:
We have successfully identified the mule and have alerted our spy network! In an unfortunate turn of events, the mule happens to be our partner, Agent X, and now we are being suspected as a traitor as well. Since we are highly skilled, Headquarters knows that the Lie Detector won’t work on us, but we have been placed off-duty until we can prove that we are innocent.

Before we were removed from duty, we were able to use the Lie Detector to find out that the enemy had thousands of civilians under control in a secret Discord server. The civilians are being brainwashed with enemy propaganda every day. To prove our innocence, we decide to go undercover and infiltrate the enemy’s Discord server. With the help of Agent X, we have been added to the server as an administrator. Our plan is to create and install a Discord bot that automates encrypted messages to the civilians and alerts them about the situation so that they can escape.

## Let’s Build

### Pre-reqs:
- Admin access to a Discord server
- A cool undercover Agent name for our Discord bot
- Optional: a cool undercover Agent profile picture for our Discord bot

### Part 1: Set Up Node.js Project
Today, we will be building this with Node.js. If you’re curious about how to build this project using Ruby, cURL, Powershell, Go, PHP, Python, or Java, let us know: `https://discord.com/invite/courier`. You can also access code for these within our [API reference](https://www.courier.com/docs/reference/automation/invoke/). Let’s get started:

- Create a new project folder.
- Create three new files: “index.js”, “.env”, and “.gitignore”.
- Install [dotenv npm package](https://www.npmjs.com/package/dotenv) to store variables: `npm install dotenv --save`

    Import and configure dotenv by adding to top of index.js: `require("dotenv").config();`

- Similarly, install [node-fetch npm package](https://www.npmjs.com/package/node-fetch) to make API calls: `npm install node-fetch@2`

    Import and configure node-fetch by adding to top of index.js: `const fetch = require("node-fetch");`

### Part 2: Create a Discord Bot
- [Sign up for (or log into) Courier >](https://courier.com/hack-now)
- Open Discord provider in Channels. Here we will need our Discord bot token to continue.
- In order to access a Discord bot token, we’ll create a Discord application and add a Discord bot.
    - Click on “New Application” within the [Discord Developer Dashboard](https://discord.com/developers/applications).
    - Type the app’s name and click “Create”.
    - In the left menu, open the “Bot” page and click “Add Bot”. We can update the icon and username (bot icon file can be found in the GitHub linked above).
- Once the bot has been created, copy the bot token provided and paste it in Courier (make sure to keep this token private).
- We will need to give this application permission to post as the bot within our server. Check out the [Bot permissions documentation](https://discord.com/developers/docs/getting-started#adding-scopes-and-permissions).
    - Within the application, head over to OAuth2 and click on URL generator
    - Select the `bot` scope
    - Select the following permissions: `View Channels`, `Send Messages`, and `Read Message History`
    - Go to the generated URL below. This URL will invite the bot to the server and authorize it with the permissions chosen.
- On Discord, click on User Settings (next to username on the bottom left). Access the Advanced settings page and enable Developer Mode ✅.
- Back in the Discord server, right click on the channel and copy the channel ID (bottom of list). Add this as the value of `channelID` in the .env file within the project and save it as a variable within the index.js file:

    ```json
    const channelID = process.env.channelID
    ```

Now, Courier has access to sending messages to this server as the bot.

### Part 3: Send Messages
- Create a new notification within the [Notification Designer](https://app.courier.com/designer)
- Add the Chat notification channel with Discord as the provider
- Select on the Chat channel on the right to edit the message

![image6](//images.ctfassets.net/z7iqk1q8njt4/5VaUY0gl7ILbrIf5I6ib3x/c579d27b7ec6c0f0782ffbc71bd3c25f/image6.gif)

- Write and publish the message. We need to create a clear message that will indicate to our civilians how to escape. Our message will be: `Run while you can. You can find shelter here: https://discord.com/invite/courier.`
- Copy the notification template ID from the notification’s settings and add it as the value of `templateID` in the .env file within the project and save it as a variable within the index.js file:

    ```json
    const templateID = process.env.templateID
    ```

![image3](//images.ctfassets.net/z7iqk1q8njt4/3uNICG76LUrNFmJ8XWzkfw/6774fa85e51e866436c82957ad6353ce/image3.gif)

- Create a test event and replace the `channel_id` in the JSON with the `channel_id` we received from Discord earlier.

    ```json
    {
      "courier": {},
      "data": {},
      "profile": {
        "discord": {
          "channel_id": "768866348853383208"
        }
      },
      "override": {}
    }
    ```

- Test a message to ensure that the Discord provider integration is working correctly.

![image4](//images.ctfassets.net/z7iqk1q8njt4/5GfnsGxTYn4iEAhKnheqIb/41c562b0811dbac8dae8bf3bfe7f60ec/image4.gif)

- Replace the message with a variable `{secretMessage}` so that, later, we can edit the message from our code directly.

![image2](//images.ctfassets.net/z7iqk1q8njt4/RBa7sDpfdeamGi1b2WpoV/57ccc96254356889c55da8676b732d15/image2.png)

### Part 4: Encrypt Message with the Morse API
- Create an asynchronous function called `encryptMessage()`, which takes `originalMessage` as a parameter. This function will call the Morse API, which will allow us to translate any message from English to Morse code. The enemy will have to spend more time and resources into decrypting our messages, which will give our civilians time to escape from the server.

    ```jsx
    async function encryptMessage(originalMessage) {
    }
    ```

- Let’s define the GET API call options:

    ```jsx
    const morseOptions = {
    	method: 'GET',
    	headers: {
    		Accept: 'application/json',
    		'Content-Type': 'application/json'
    	}
    };
    ```

- We need to attach the `originalMessage` function parameter to the Morse API endpoint:

    ```json
    const morseEndpoint = "https://api.funtranslations.com/translate/morse.json?text="+originalMessage
    ```

- We need to be able to access the translation from this API call in the body of the Courier API call. To call the API, we can use node-fetch as we did before.
    - Create a variable called `morseResponse`, which will hold the entire response from this call.
    - Convert the JSON object into a JavaScript object `morseResponseJSON` so that we can read it within our code.
    - Get the translated message out of that object and save it in a new variable called `encryptedMessage`.
    - Return `encryptedMessage` so that we can call this function to access it elsewhere.

    ```jsx
    const morseResponse = await fetch(morseEndpoint, morseOptions);
    const morseResponseJSON = await morseResponse.json();
    const encryptedMessage = morseResponseJSON.contents.translated;
    console.log(encryptedMessage);
    return encryptedMessage;
    ```

![image1](//images.ctfassets.net/z7iqk1q8njt4/3xp8SErhajuhxiMVB2iX2W/43ce98adc0c2c64ca833e46e304b7779/image1.png)

*NOTE: The Morse API has a rate limit, which may give you an error if you run it too many times within the hour. In this case, you will have to wait for some time before continuing.*

### Part 5: Automate Messages
[Learn about Automations >](https://www.courier.com/docs/automations/)

[Check out the Automations API reference >](https://www.courier.com/docs/reference/automation/invoke/)

- Create a new asynchronous function called `runDiscordAutomation()`, which will call the `encryptMessage()` function to translate a message and use the Courier API to automatically send messages to the enemy Discord server everyday.

    ```
    async function runDiscordAutomation() {
    }
    ```

- Before we can run our message through the Morse translation API, we need to ensure that it is in the correct format, with all spaces converted into their URL encoding, `%20` as shown below. We can call `encryptMessage()` with `originalMessage` as a parameter to translate it. `encryptedMessage` will evaluate as the translated message.

    ```jsx
    const originalMessage = "run%20while%20you%20can%20you%20can%20find%20shelter%20here";
    const encryptedMessage = await encryptMessage(originalMessage);
    ```
- Add the link to the safe server in the notification template within the designer: “[https://discord.com/invite/courier](https://discord.com/invite/courier)”

- Let’s define the Courier Automation endpoint and options. Here we will need access to our Courier API Key, which can be found within the [Courier Settings page](https://app.courier.com/settings/api-keys). Save the first value in the .env file as apiKey and access it in this file as process.env.apiKey.

    ```jsx
    const automationsEndpoint = "https://api.courier.com/automations/invoke"

    const courierOptions = {
    	method: "POST",
    	headers: {
    		Accept: "application/json",
    		"Content-Type": "application/json",
    		Authorization: 'Bearer ' + process.env.apiKey
    	},
    	body: JSON.stringify({
    		//next steps
    	}),
    };
    ```

- The body object within the options will encompass two objects: `automation` and `data`

    ```json
    body: JSON.stringify({
    	"automation": {
    	},
    	"data": {
    	} 
    }),
    ```

    - The `automation` object will include a `steps` array, which will consist of all steps required for the automation. Our automation consists of reminders that are sent once a day - in this case we will be adding three steps: a send step, a delay, and another send step (so on).

        ```json
        "automation": {
        	"steps": [],
        },
        ```

    - Each step will need to be defined with two objects: the type of `action` (send, delay, cancel, etc.) and `message`. The `message` consists of the notification template ID (we saved this in the .env file earlier) and information about where this message is being sent. A Discord message requires either a `user_id` or a `channel_id`. In order to reach as many innocent civilians as possible, as quickly as possible, we will directly send messages in a channel.
    - This is what the send and delay steps would look like:

        ```json
        {
        	"action": "send",
        	"message": {
        		"template": templateID,
        		"to": {
        			"discord": {
        				"channel_id": process.env.channelID
        			}
        		}
        	}
        },
        ```

        ```json
        {
        	"action": "send",
        	"duration":"1 day"
        },
        ```

    - The data object would need to contain the `encryptedMessage`:

        ```jsx
        "data": {
        	"secretMessage": encryptedMessage
        }
        ```

    - [Learn more about sending to a channel via Courier >](https://www.courier.com/docs/guides/providers/direct-message/discord/#sending-a-message-to-a-channel)
- For testing purposes, it’s easier to either remove 1 delay step or keep it at a short period like `1 minute`
- Finally, we can use node-fetch again to call the Automations API and trigger this automation

    ```jsx
    fetch(automationsEndpoint, courierOptions)
        .then((response) => response.json())
        .then((response) => console.log(response))
        .catch((err) => console.error(err));
    ```

![image5](//images.ctfassets.net/z7iqk1q8njt4/DToIls5IJymsGD2WVpqNr/1eff78ca95f8a643f6bfbcab2cfc3cdc/image5.png)

## Conclusion

Our Discord bot is ready to save some civilians. Try building a Discord bot of your own and tweet a screenshot of your Courier automated messages in action, and we will send a gift to the first three Secret Agents to complete this task! Head to [courier.com/hack-now](http://courier.com/hack-now) to get started. Don’t forget to submit your project to our [Hackathon](https://courier-hacks.devpost.com/) for a chance to win over $1000 in cash and prizes!

### Quick Links

🔗 GitHub Repository: [https://github.com/shreythecray/infiltration](https://github.com/shreythecray/infiltration)

🔗 Courier: [app.courier.com](https://bit.ly/3QPiFg3)

🔗 Register for the Hackathon: [https://courier-hacks.devpost.com/](https://courier-hacks.devpost.com/)

🔗 Discord Application and Bot Guide: [https://discord.com/developers/docs/getting-started](https://discord.com/developers/docs/getting-started)

🔗 Courier Discord Provider Docs: [https://www.courier.com/docs/guides/providers/direct-message/discord/](https://www.courier.com/docs/guides/providers/direct-message/discord/)

🔗 Courier Automations Docs: [https://www.courier.com/docs/automations/](https://www.courier.com/docs/automations/)

🔗 Courier Automations API Reference: [https://www.courier.com/docs/reference/](https://www.courier.com/docs/reference/)


Brunette woman (spy) sits at a desk, hacking a computer.

serverless-lie-detector-header

Our plan is to create and install a Discord bot that automates encrypted messages to the civilians and alerts them about the situation so that they can escape.

serverless-lie-detector-thumbnail

Create a Discord Bot that Automates Secret Messages with Node.js

Build a Serverless lie detector that uses AI for facial recognition (with Node.js, Azure Functions, Azure Face API, and Courier API)

Build a Serverless Lie Detector with Node.js, Azure Functions, Azure Face API

Build a Serverless Lie Detector that uses AI for Facial Recognition

nick-headshot

Nick Gottlieb

Product notifications are a mission-critical component of your product that can’t be left to chance. However, notification channels are ever-evolving, and you need to keep up in order to reach users when, where, and how they prefer to be reached.

A future-proof multichannel notifications strategy helps you stay in touch with your users without coming off as intrusive, non-responsive, or antiquated.

## What Is a Multichannel Notifications System?
A multichannel notifications system is designed to seamlessly route and deliver messages about product-related events to users across multiple channels and providers.

For companies that require a detailed and wide-ranging strategy to reach customers and potential users, a multichannel notifications system can help your company reach out to users in the way they prefer to be contacted. One of our clients, Bluecrew, a W-2 staffing platform that connects hourly workers with employers, recorded a [55% improvement](https://www.courier.com/blog/courier-bluecrew-multi-channel-notifications/) in job application rates after scaling their notifications infrastructure with Courier.

With multiple communication options, businesses need to think about how they’ll communicate different events to their users, including:

* Transactions: notifications that provide a summary of transactional updates
* Alerts: notifications that require high assurances of deliverability and visibility 
* User activities: notifications that update users about key activities within their accounts or profiles
* Required actions: notifications that proactively let users know when action is needed
* Digests: notifications that deliver a dynamic summary of events
To do notifications well, a company/product requires a multichannel notifications strategy that can adjust with the times.

## Traditional Approaches to Multichannel Notifications Systems Fall Short
There are two traditional approaches to managing the notifications strategy for your apps: limited channel notifications and custom channel support.

### 1. Static and uncustomizable approach 
This is a notifications strategy that supports a handful of channels that are the only means of communicating with users, irrespective of the user’s needs or preferences. A strategy that supports a limited number of channels is common in legacy solutions with ancient codebases that are best left undisturbed. 

However, many newer products and services might unwittingly end up with a limited number of channels after a few years. Sometimes, product managers don’t consider how they’ll support notifications until the last minute. Then you are forced to choose whatever notification channel seems to work best at that time. The challenge with this approach is that you may never quite get around to introducing new channels, and it becomes impractical to make changes as your codebase grows. 

In contrast, a multichannel product notifications strategy that begins during product development allows you to bake agility into your plans to add new channels over time.

### 2. Customizable, yet unscalable Approach
This is a notifications strategy in which the company actively works to support new channels as needs arise. This custom-channel notifications strategy is especially common with startups because they tend to move fast. Many startups, for instance, adopt the [blitzscaling product development](https://youexec.com/book-summaries/blitzscaling-by-reid-hoffman-and-chris-yeh) approach that prioritizes speed over efficiency. In this case, you’d probably lean toward writing code to support new channels as the need arises instead of thinking strategically about how to manage notifications in the future. 

In the early days, the development team might power through the night or weekend to update your code so it can support a new notification channel, and it’s common to do this every time there’s an additional notification channel that needs support. 

While this ad-hoc approach might work in the short term, it eventually becomes unsustainable as your business grows. As your product development process matures, decision-making requires input across cross-functional teams. It’s not as easy to adapt on a whim.

## A Future-Proof Notifications System Adapts to Changing Communication Preferences
A notifications strategy that takes into consideration that we live in a multichannel world is future-proof. It is designed to adapt to the dynamic needs of modern communication without being slow, expensive, or outdated for your stakeholders.

A future-proof multichannel notifications strategy should let you notify users across channels, integrate with your existing tech, and reroute messages to different channels, all while being easy to use and scaling with your company. 

### Enable Notifications Across Multiple Channels Today
A multichannel notifications strategy lets you switch across channels to meet the needs of your users. 

For instance, SMS is a popular notification channel in the United States, but there’s a strong [preference for WhatsApp](https://www.statista.com/statistics/291540/mobile-internet-user-whatsapp/) in emerging markets. For example, 96.4% of Brazil’s digital population, 95.4% of South Africa’s digital population, and 95.2% of the digital population in Argentina actively use WhatsApp monthly. 

Similarly, [WeChat](https://www.statista.com/statistics/250548/most-popular-asian-mobile-messenger-apps/) is the leading communication channel in Asia with 1.26 billion monthly active users, and emails seem to be the [preferred communication](https://www.statista.com/statistics/417288/preferred-delivery-service-convenience-options-in-europe/) channel in Europe with 72% of respondents preferring emails over WhatsApp, SMS, or other communication channels. Your product notifications system must be robust enough to deliver notifications across all these channels.

### Deliver Notifications Across Multiple Providers on the Same Channels
You also need to be able to pivot the delivery of notifications through different providers within a channel as providers compete on features, pricing, and other metrics. 

The benefits of being able to integrate with multiple providers accross a notifications channel include having a fallback option to ensure delivery of one provider has a downtime. Another benefit is that you might be able to shop around fo the best price per message based on the price offering of different providers in different countries. 

Therefore, you may want to be able to integrate with the following providers (and potentially more) across all the communication channels.

* [For emails](https://www.courier.com/guides/email-notifications/): SendGrid, Mailgun, Amazon SES, SparkPost
* [For SMS](https://www.courier.com/guides/sms-notifications/): Twilio, MessageBird, Plivo, Telnyx 
* For chat: WhatsApp, [Microsoft Teams](https://www.courier.com/docs/guides/providers/direct-message/microsoft-teams/), [Slack](https://www.courier.com/docs/guides/providers/direct-message/slack/), FB Messenger
* [For push](https://www.courier.com/guides/android-vs-ios-push-notifications/): Firebase, OneSignal, Airship, Expo

### Route Notifications Across Channels and Providers
The preferences and needs of users are dynamic; therefore, users who only want email notifications today might later decide they want push notifications. 

The challenge with changing user preferences is that notification formats differ across channels. For instance, a notification requiring a user action sent by email needs a button, whereas the same notification sent as an SMS needs a hyperlink. 

### Make It Easier to Expand to Future Channels 
Your product notifications strategy should enable forward compatibility to integrate with new channels and providers as they emerge.
Right now, Zoom and Microsoft Teams are the [leading business communication tools](https://www.statista.com/statistics/1246368/communication-services-usage/), but that could change in five years; after all, Skype [used to be the standard](https://www.bloomberg.com/opinion/articles/2021-06-04/how-microsoft-let-skype-lose-out-to-zoom?sref=eDGWeidQ) some 10 years ago. When developing your product notifications strategy, you should insist on simple, elegant, and potentially modular code that can be easily updated to support new channels. 

### Scale Effortlessly for More Users and Messages 
As your business grows, your notifications strategy should accommodate your company’s size, from startup to enterprise and beyond. For instance, Gojek, a transport and logistics company in Southeast Asia, says it delivers more than [1 million push notifications per hour](https://www.gojek.io/blog/how-we-manage-a-million-push-notifications-an-hour). 

While your products may not need to send 1 million notifications per hour, you need to think about how the architecture of your product notifications system is designed to initiate, send, and deliver (and, where necessary, store) thousands of notifications as easily as it handles hundreds of notifications per day.

### Enhance the Agility of Your Product Notifications Strategy with Courier 
Building a custom multichannel strategy that adapts to a multichannel and fast-changing communication infrastructure is slow, expensive, and frustrating. Courier is on a mission to improve software-to-human communications with APIs. Courier helps you handle the notifications experience in your products, so you can focus on building your business. 
Courier empowers you to future-proof your multichannel product notifications strategy with shortened development time, dynamic templates, and analytics.

### APIs Shorten the Development Time and Costs
Courier shortens the time it takes to build a multichannel notifications strategy by providing you with APIs and SDKs, so you don’t have to start writing code from scratch. Our APIs can be integrated into all communication channels, from push to emails, and you can get support for more than 60 providers in a single API. Courier’s APIs also handle user data, templates, preferences, and message orchestration for a seamless product notification experience.

Additionally, we provide SDKs for all major languages to enable you to implement geographical-based localization in the delivery of your notifications. 

### Templates Make It Easier to Add More Channels 
If you develop your templates manually, it might be difficult to manage the different variations of the templates as you add new channels and providers. Courier’s templating system has an omnichannel architecture. Courier Studio supports drag-and-drop designs, and you can use JSON-based templates to produce templates efficiently. Courier automatically generates notification templates that fit the format of each delivery channel before routing the messages through the right provider(s).

### Analytics Improves the Notification Experience for Your Users
Courier is also outfitted with analytics that helps you understand the notification experience of your users. Visibility into the quality of their experience also provides you with insights on how to optimize the notification experience across all the channels and providers you support. 

### Scale Your Notifications System Across Channels Effortlessly
Courier’s modular model enables you to add new channels, replace providers, and route messages across channels in a unified system. Courier also functions as a low-code solution. So anybody on your team with minimal technical skills can add channels in minutes without a developer or knowing how to write code.

Are you a PM who needs to establish or improve their app’s notification system? Check out our [ebook](https://www.courier.com/view-developer-guide/) about what it takes to build a great notification system or just learn more about Courier by [scheduling a demo](https://www.courier.com/request-demo/).


fish swim together to form a bigger fish in the ocean, protecting the integrity of the larger fish formation

future-proof-notifications-header

A future-proof multichannel notifications strategy helps PMs stay in touch with their users without coming off as intrusive, non-responsive, or antiquated.

The Importance of a Future-Proofed Multichannel Notification System

future-proof-notifications-thumbnail

MelissaBrodsky_Headshot

Melissa Brodsky

The daily bombardment of alerts dinging, beeping, and ringing from all those applications we use is enough to drive someone completely crazy. Yet, for some inexplicable reason, we allow ourselves to be interrupted by Slack in a way we wouldn’t from any other platform. 

Even though it seems completely counterintuitive, and despite the sheer amount of daily notifications (because we still can get a bunch of notifications from Slack alone), we love and use Slack—a lot. It’s no wonder it’s the most popular platform, completely dominating the internal communications space.

The company has taken a holistic approach to its overall user experience and has created a product that delivers notifications that fit seamlessly into our lives. They’ve made it easy to set up, work, collaborate, and communicate all in one place. The onus tends to fall on SaaS product managers to build great user experiences for their customers. A major component of an app's UX is excellent communication that users can customize based on their own preferences and toolsets. Slack is one app that does this extremely well and PMs can learn a lot from its many integrations and malleable notification preferences.

## What is it About Slack?
There’s a reason over 12 million people across the globe use Slack. It has everything to do with the fact that the platform incorporates so cohesively into our work lives that it’s impossible not to be a willing participant. Integrations and automations consolidate all the notifications in one place—completely reducing notification bombardment, thanks to all the preferences and controls they allow their users to set. This means the user is more apt to tolerate and act on them.

Sure, Slack is *just* another work tool, and this means we can’t exactly turn it off during work hours. But, because Slack’s preferences give us so much control over what we receive and when, even if we have it open in the background, we won’t be constantly disrupted by alerts throughout our entire day. Because we have [power over the functions](https://www.courier.com/blog/slack-notifications-flowchart-strategy/), we can snooze notifications, lower the volume, or even set our status to deter constant interruptions. Even better is that it’s easy to navigate for engineers and non-technical folks. 

In theory, Slack doesn’t seem like the type of application we’d use so much, yet here we are. It doesn’t matter if your company works entirely remote or in-person; Slack makes working with colleagues easy. Cohesiveness produces better products. 

Why, though?

It comes down to how well Slack does the integrations, automations, and notifications. It’s a platform that is so user-friendly in a way not many other platforms have accomplished. Here’s the thing: They are so open and obvious about their processes, which are fully documented on their site, that there’s no reason we shouldn’t take a page or two from their playbook when building an application. 

### Here are some of the things Slack does that would be beneficial to your product:
Whether they realize it or not, users expect to have control over their notifications. From volume control to delivery frequency, preference settings are essential when creating a successful application—Slack respects its users by only sending notifications they’d expect and nothing more.

Based on a belief that notifications are a relationship based on trust, Slack has an entire team devoted specifically to notifications. Because Slack only sends notifications their users expect and need, they’ve done a spectacular job instilling confidence between their platform and users, which makes the platform attractive to acquiring and retaining customers. 

Slack offers something for everyone with robust key features such as IMs, file sharing, notifications, integrations, and group chats. The platform’s appeal extends across all departments, from design to engineering to marketing to sales—everyone loves it because there’s something for everyone *to* love. 

Product and support teams use Slack to collaborate internally on roadmap and delivery tasks but also use Slack to stay close to customers via external channels.

Developers appreciate how easy it is to automate repeated tasks (via bots), control their focus hours, and save certain messages. Essentially, they can hack Slack to customize to their own needs, making it easier to meet the requirements product managers give them without worrying about distractions or inefficiencies. 

## Why Slack works so well  
There are well over 2400 apps in the Slack app directory. Whether you have the free or paid version of Slack doesn’t matter; you gain access to everything they offer. And, chances are, because of how robust that library is, the apps you need to get your work done are available. Plus, if it’s an app you’re creating, it can be easily integrated. 

Setting up all your Slack applications will help you communicate and collaborate more efficiently and effectively. Which, in turn, will boost productivity. Namely, you don’t have to leave the platform to toggle back and forth between all the different tools and applications you use— eliminating the clutter of open tabs and lowering frustration levels. 

### Notifications, whether in-app, SMS or email, should:
* Be actionable
* Be engaging
* Be relevant
* Be timely
* Be valuable

That’s precisely what users get when they connect Slack with the integrations. And that’s what most users would want from any application they’re receiving notifications from—their time and attention are too valuable to waste. When there’s no point in the alerts the user gets, they unsubscribe, silence, or delete the application entirely. 

## Thinking about your notification system
*“Control in context is about presenting users with an opportunity to adjust their notification settings at the exact moment those settings are relevant.”* –Liza Gurtin, former product lead, Slack. 

Slack should be the benchmark when considering how you’re servicing your customers within your application. By allowing yourself full control of the notification experience, you are subscribed to relevant channels and can consume the notifications you want when you’re ready and available to receive them. Slack allows the right people, when setting the proper controls, to be notified at the right time. Which is what any good notification system should do. 

By controlling your own notification experience, you can ensure that you're subscribed to all of the relevant notifications/channels/etc, but be able to consume those notifications when you're ready and available.

### Some of the most popular integrations to check out are: 
* Google Calendar: Add notifications to view your calendar and keep track of all your events 
* Salesforce: Easily change lead status and receive timely alerts.  
* Zoom: Meet directly through Slack, no switching back and forth through apps 
* Github: Receive notifications, share links, close, open, and pull ticket requests, and use the deployment API 
* Giphy: Search and send gifs to your colleagues. What working day is complete without having a giphy war?

When looking at your app functionality compared to popular Slack integrations, the most important takeaways for building a notification system should be user experience and control. Streamlining your users’ collaboration and processes combined with other productive functions will help improve the day-to-day work.  

Slack exposes robust APIs that make the platform a desirable destination for building useful applications on top of it. Slack can be considered as an app store for workspace-related tasks, such as requesting PTOs (Lattice or other HR software), rewarding your co-workers for great work (HeyTacos), and automating code deployments (Github actions), communicating analytics or product KPIs on your team channel every morning, and the list goes on. Any question asked more frequently can be converted into some sort of automation in Slack. Engineers don't like to solve the same problem again or answer the same questions multiple times, so they naturally like Slack's extensibility.

### What you should think about when implementing your notification system 
Your users (and their customers) expect their [information to be secure](https://www.courier.com/blog/security-for-your-saas-communications/). Sensitive data is being sent regularly through SaaS platforms and are susceptible to breaches and hacks. Users expect their tools to maintain the highest security measures while providing an exceptional user experience. 

People are working remotely and on the go, so being able to quickly and easily switch between devices is not only a necessity, it’s an expectation. Your app must seamlessly go from computer to phone to tablet for functionality, collaboration, and communication, but also to scale teams and [approve workflows](https://www.courier.com/blog/approval-workflows/). 

When thinking about what to implement into your own notification system, consider anything necessary for a company’s output to help your users make informed business decisions and to make the most of notifications that convert customers and increase buying power.

For the average user, they click the “Add to Slack” button and their chosen integrations are installed into their Slack workspace. As an product manager, you’re tasked with creating the customization to simplify your end-user experience. You must set smart defaults while allowing control to fall into your customer's hands. 

The good news is that you don’t have to reinvent the wheel. [APIs for many integrations](https://api.slack.com/) are available and ready for you to use when building your own great notification system. Keep in mind that many 3rd-party services like Courier can handle any application builds for you, allowing you to focus on other important facets of your project. [Sign up](https://www.courier.com/request-demo/) for Courier now to learn more about how we use Slack integrations. 

When it [comes to integrations](https://www.courier.com/blog/building-a-slack-integration/), don’t cut corners. Otherwise, your customers will likely silence your app entirely. 

The inspiration for this article comes from a [Crafting SaaS](https://www.youtube.com/playlist?list=PLUtGTSNwrt-AEW-uCk4lYlcjrQvT1V8Ol) episode where we discuss all things notifications and user expectations. You can check it out here:

<iframe width="560" height="315" src="https://www.youtube.com/embed/tKANDAB8AUs" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

Level up your product’s notifications with Courier. [Sign up for a free account](https://app.courier.com/signup) today!


Castle floating in the night sky with wires connecting to many city buildings below.

why are we ok with notifications from slack-header

Slack is one app that Product Managers can learn a lot from because of its many integrations and malleable notification preferences.

why are we ok with notifications from Slack-thumbnail

Why Are We Okay with Notification Interruptions from Slack?

suhas-headshot

Suhas Deshpande

For many organizations, Slack is the software of choice for business communication. Slack’s ubiquity in modern companies makes it one of the first notification integrations a SaaS company might want to build, possibly after email and mobile push notifications.

In our experience, Slack notifications are a great way to reach business users (as Slack is mostly used in a business context) with time-sensitive alerts or action items while they’re at work. Because the users are already in work mode, Slack notifications are suitable for anything from collaboration on documents and spreadsheets to workflows like approval requests or data access permissions. Slack is less suited for notifications outside of a work context or out of working hours.

To be able to send messages in Slack, a software system must integrate with [Slack’s API](https://api.slack.com). The resulting integration will allow your application to send Slack messages with helpful information to a Slack channel or a direct message thread. Here’s an example of a Slack message coming from [GitHub’s Slack integration](https://github.com/integrations/slack):

![github-slack](//images.ctfassets.net/z7iqk1q8njt4/20nZJwKjHk3HuFbsyPcANb/0fdc352178ee450eaab124d5b747c436/github-slack.png)

Here’s another example of a Slack integration from [Salesforce](https://help.salesforce.com/s/articleView?id=sf.digital_hq_slack_rn_approvals.htm&type=5):

![salesforce-slack](//images.ctfassets.net/z7iqk1q8njt4/1GKPrZsIjHdfb8u9mStEBt/7827b2be4ceb4b9325dafe8ac685c50b/salesforce-slack.png)

Many organizations don’t quite know what to expect when building an integration for sending messages from their SaaS product to a Slack channel or a direct message. In this post, we offer details for developers who are planning to build a Slack integration for their product.

## Technical aspects of a Slack integration
From a technical perspective, Slack offers a fairly conventional HTTP REST API, which will be straightforward to understand for developers who deal with web systems. The functionality made available through the API is extensive, and there are complex parts to it, but most Slack integrations for SaaS will likely only need to send messages. Messages are the core of Slack’s functionality, but we cover other actions that your app might need to take in Slack below.

For sending messages, the [Sending Messages guide](https://api.slack.com/messaging/sending) in the Slack API documentation is a helpful starting point. The steps required to send a message are:

1. Create a Slack app.
2. Request the correct permissions from the user.
3. Compose the message using one of Slack’s message types (or [blocks](https://api.slack.com/reference/block-kit/blocks)).
4. Send the message via an API call.

The main way to send a message is the POST chat.postMessage endpoint, but it’s also possible to use other endpoints with slightly different functionality: the [chat.postEphemeral](https://api.slack.com/methods/chat.postEphemeral) endpoint, for example, sends messages that are only visible temporarily and for a specific user (helpful for things like error messages). It’s also possible, and in some cases easier, to send messages using an [incoming webhook](https://api.slack.com/messaging/webhooks).

Beyond sending messages, other functionality that you can implement with Slack’s API includes:

* Slash commands — simple chatbot functionality via commands in Slack DMs or channels
* Editing messages that have already been sent — for example, if information has been updated
* Bots that respond to direct mentions and interactions — for example, [Hubot](https://slack.dev/hubot-slack/) is an implementation of such a bot used by hundreds of teams
* Bots that monitor all message traffic in a specific Slack channel or direct message thread (less common due to how inefficient it is to scan all messages in high-volume Slack channels)

Many software teams choose to develop all functionality relating to Slack or another messaging service either in a dedicated microservice (if you use microservice architecture) or at least in a separate section of your monolithic app. The reason to do this is to avoid tightly coupling the way you think about notifications to Slack’s API — doing so could cause issues when the time comes to add support for other messaging APIs. Another reason to use a separate service or namespace for the Slack integration is to implement message retries and other reliability-focused tweaks. Such code would be too complex to include inside your business logic.

In our experience, there are a few points that developers might not be thinking about when building a Slack integration, and we encourage you to consider them:

1. Many of our users run into Slack API rate limits at some point during their usage cycle. So it’s likely that you will need to retry sending a message at some point because of rate limits. Consider including retry functionality from the very beginning.
2. Messages sent by integrations might need to include images or other files, so consider how you’ll handle attachments. Slack offers convenient [file upload](https://api.slack.com/methods/files.upload) functionality via the API that you can use, and it comes with built-in access controls. But you might prefer to [use your own storage](https://api.slack.com/messaging/files/remote). In that case, authenticating requests to files can become painful because you won’t have Slack’s access control mechanism to rely on.
3. Make sure that your system is compliant with relevant regulations, in case you’re sending notifications that include PII or other sensitive data. We wrote about this recently in *[The Developer's Guide to SaaS Compliance](https://www.courier.com/blog/the-developers-guide-to-saas-compliance/)* — check it out. 

## User experience of a Slack integration: Our recommendations
When we advise our customers about Slack integrations, most of our advice centers less on the implementation details and more on the product functionality and customer experience side. We see teams who are building Slack notification functionality for their SaaS focus too much on sending Slack messages and not enough on the value those notifications deliver to their users.

In this section, we offer a few recommendations on designing a helpful Slack notification experience.

### Use Slack status information for optimal notification experience
Something that we find useful for many customers is keeping track of Slack statuses (the little “active” and ”away” indicators you see on people’s profiles). Consider whether you even want to send Slack notifications if someone is marked as being away in Slack — they might not be on their computer, or they might have intentionally changed their status. Is the notification you’re sending in Slack going to be actionable for someone on their phone? For many SaaS applications, the answer is no.

Our recommendation on handling status is to send Slack notifications when the user is active in Slack, and when they are not active, using a different channel like email or mobile push.  We cover the topic of notification routing in *[Building a Routing and Preferences Service for Notifications](https://www.courier.com/blog/routing-and-preferences/)*. 

### Create message templates and have a workflow for updating them
In a SaaS product, it’s very unlikely that you’ll need just one type of Slack message. An app can require tens or hundreds of different notifications to be sent via Slack — and managing such large numbers of messages in your codebase can get tricky.

We recommend using templates instead of hard-coding messages in your application. It’s likely that your message templates will change over time, and you might want to add new notification types as you develop your product. By relying more on templates you can simplify the code review process — it’s easier for a peer to review a template change in a separate file than to jump between templates and code.

Another recommendation is to make templates editable outside of the code review process. This capability will enable colleagues outside of the development team to change and tweak notification templates themselves without the need to commit directly to the codebase.

### Translation and language preferences
Are you going to only offer notifications in one language, or multiple? If you’re offering multiple languages, how does a user configure their preferences? You might want to add functionality within the Slack app that allows users to configure their language settings, or have a section within your web app (outside of Slack) with notification preferences. In any case, you need to store language preferences for each user and, eventually, have a good way to store translated versions of notification text as well.

We also recommend that you consider the translation workflow for notification text — the translators will likely not be able to navigate your codebase due to limited permissions or lack of technical context. Making it straightforward for the translators to work with your notification text will make it faster to implement new notification languages.

## Slack integrations made easier with Courier
In this article, we’ve covered our recommendations for building a successful Slack integration for your SaaS product.

Prefer not to implement the integration yourself?

With Courier, sending a Slack message only requires one API call to Courier’s [send](https://www.courier.com/docs/guides/providers/direct-message/slack/#send-a-message) endpoint. As part of that endpoint, Courier uses [profile information](https://www.courier.com/docs/reference/profiles/) to customize notifications, from individual preferences and personal information to language settings. Courier also offers [templates](https://www.courier.com/features/templates/) that can be created in a well-designed web user interface (with a translation workflow built-in) and [automations](https://www.courier.com/features/automations/) to define more advanced notification logic. And, by the way, once you integrate Courier, you can send other message types — like Microsoft Teams, Discord, email, SMS, and more.

If you’re interested in offloading building a strong Slack integration for your SaaS notification system, [explore Courier](https://app.courier.com/signup) and see if buying might be a better option than building in this case!

*Illustration by [Rebekka Dunlap](https://www.rrebekkaa.com/)*

A little robot with a Slack logo is connected to all types of speech bubble representing notifications

slack-integration-header

In this post, we offer details for developers who are planning to build a Slack integration for their notification system.

Courier [Integrations]

Build your first notification in minutes

Build your first notification in minutes

Product

Developers

Resources

Company