nick-headshot

Nick Gottlieb

## TLDR
Easily connect your existing Segment events to trigger and send product notifications.

## Background
We’re excited to announce that we now easily [integrate with Segment](https://segment.com/docs/connections/destinations/catalog/courier), the leading customer data platform.

After 2.5 years and hundreds of customers, our community has convinced us that having additional event sources to act as notification triggers would help expand use cases and reduce the effort required to get up and running with Courier.

Now, Segment and Courier users can:

* Configure Courier as a Segment destination
* Trigger product notifications without writing any additional code
* Take advantage of Courier’s complete product notification platform, including omni-channel routing, dynamic templates, preference management, automations, and more

Don’t use Segment? Remember that you can easily [integrate the Courier Send API into your codebase](https://docs.courier.com/reference/sendmessage) — a single API that can notify your users over any channel. See all of our channel providers in our [Integrations section](https://app.courier.com/integrations).

## Product notification infrastructure without additional code 
While Courier is still a developer API first and foremost, Segment users can now take advantage of the complete Courier platform, including omni-channel routing, dynamic templates, preference management, automations and more by simply adding Courier as a Segment destination. The only requirement is that you are currently sending any events you would want to use to trigger a Courier notification to Segment.

## Courier + Segment use cases
While the ways in which you can use Courier and Segment to automate your product notifications are endless, below are a few highlighted examples of how customers are using Courier and Segment today. Also check out Courier's [case study with Hospitable.com](https://www.courier.com/customers/hospitable-automates-communication-using-courier/) to learn how they use our Segment integration.

### Transactional notification
Using the Segment ‘account created’ or ‘signup’ event, you could send a welcome message to all new users. While the most common channel for welcome messages is email, you could also send a welcome SMS, Slack message, in-app notification, or one of many other channels supported by Courier. You could even set up an automated sequence to nurture new signups as they progress through your product funnel.

![segment-courier-integration-1](//images.ctfassets.net/z7iqk1q8njt4/3PATYalrMWc9Xw128voWkj/207459968e89aa5b23c1117f290bead1/segment-courier-integration-1.png)
*Segment integration in Courier: Segment events, once triggered on your application, can be located in Courier and linked to automations. In this example, our events are linked to the “Account Created/Sign Up” automation that sends a Welcome email to the user when triggered.*

### User activity notification 
Using any segment events you have configured that track user activity that other users may need to know about, for example a product being purchased in a two-sided marketplace, you can easily set up notification automations. One common use case is to send the seller a notification whenever one of their items has been purchased, and then to send the buyer a notification when the seller has shipped their item.

![segment-courier-integration-2](//images.ctfassets.net/z7iqk1q8njt4/JZM5fTEIQ71ahdJzgUJKM/711eda949ab43cb0e271f3ffb0de8825/segment-courier-integration-2.png)
*Segment API sample call: Segment can make calls to Courier that pass along information about how your user is interacting with the application.*

![segment-courier-integration-3](//images.ctfassets.net/z7iqk1q8njt4/6k1EjXyjqfwqZjxOUzq05K/a36a40fd1754bd9e5363ea0d22682ff1/segment-courier-integration-3.png)
*Marketplace automations triggered by Segment API call*

### Action requested notification
You can use any Segment event that requires action from a user to build notification automation in Courier. For example, if your app facilitates employee performance reviews, you may want to begin sending managers both email and Slack reminders to complete their reviews two weeks before they are due. You may then want to send a notification to the manager’s manager, letting them know there are incomplete performance reviews, two days after the due date. All of this is easily achieved, without writing any code, using Courier and Segment together.

## How to get started
The first step is to sign up for a free Courier account and then to configure Courier as a Segment destination. Once that is complete, you can start triggering notifications from Segment events by triggering notification automations from Segment events. A complete getting started guide can be found [here](https://www.courier.com/docs/guides/tutorials/how-to-send-notifications-with-segment).


The Courier logo on the left connects via dotted line to the Segment logo on the right

Courier Segment Integration

We are excited to announce that Courier now integrates easily with Segment, the leading customer data platform.

With Courier's Segment Integration, Developers Create Product Notifications Fast

The Courier and Segment logos connect to each other by dotted line diagonally

Courier Segment Integration - Thumbnail

Courier + Segment Integration: Product Notifications In Minutes

Tejas Headshot

Tejas Kumthekar

Early stage companies are constantly evolving their product to fit the market they operate in. They reach customers to keep them engaged using a high magnitude vector that contributes to their success. Architecting the communications strategy for your product thus becomes an important problem to tackle, which in turn can cause second-order effects like having to trade off the speed of product development iterations. The decisions you would have to make along the path can be hard, confusing and prone to change, and the last thing you want to invest precious time and energy in is these non-core features of your product.

In this blog post, we start by diving into Nodemailer, a module that helps send emails from your Node.js backend, and then we steer our way into writing a transport layer plugin that can help you switch downstream email service providers purely by configuration instead of tedious and sometimes massive code changes.

## Projects that have stood the test of time

In the fast growing tech industry, there’s a special place in the hall of fame for projects that have stood the test of time. [Nodemailer](https://nodemailer.com/about/) is one such project that deserves the well-earned spot. Launched in 2010, not long after Node.js’ inception, Nodemailer has been a go-to dependency for sending email messages for Node.js users. With 14k+ stars and 438k+ usages on [GitHub](https://github.com/nodemailer/nodemailer) and ~1.48M weekly downloads on NPM as of this writing, Node.js developer community has benefited immensely from the project.

Apart from a wide variety of features provided by Nodemailer, it comes with zero dependencies and has been evolving with a security-first mindset. While some of us might think how hard it can be to have zero dependencies, let's remember we’re in a Node.js world where there is a package for every little thing you could possibly imagine. Don’t believe it? Brace yourself while looking at [https://www.npmjs.com/package/is-odd](https://www.npmjs.com/package/is-odd) and [https://www.npmjs.com/package/is-even](https://www.npmjs.com/package/is-even). Yep that’s right - there’s a dependency that can help determine if a number is odd or even. No more complex arithmetic, right? 

On another note, Nodemailer’s security-first development also deserves a round of applause. Those of you who have had to frequently run audits and rack your brains figuring out how to resolve vulnerabilities would agree. Moreover, considering the scale at which projects like Nodemailer have been adopted, even a single vulnerability can have huge negative impacts on the software of the world. One recent example is a [vulnerability in the netmask npm package](https://www.securityweek.com/vulnerability-netmask-npm-package-affects-280000-projects) that could potentially play a hand in malware delivery.

## Extensibility and elegant abstractions are the cruxes

Nodemailer is highly extensible via plugins that can operate on the mail object (pre-processing step), the mail stream (processing step) or the transports (sending step). For the scope of this blog post, we’re mostly concerned about the sending step. [SMTP](https://datatracker.ietf.org/doc/html/rfc5321) is the main transport in Nodemailer for delivering messages - but can be extended using the transport plugin to a different transport mechanism. For example, if you already use [Amazon SES](https://aws.amazon.com/ses/), you can use the SES transport plugin instead of SMTP, which is built-in. Like SES, there are several email service providers out there like SendGrid, Mailgun, Postmark and SparkPost to name a few. In order to cater to the Node.js (and Nodemailer) audience, most of these providers do have a transport plugin of its own should you need to integrate with your tech stack. You can explore through all such plugins with a simple [“Nodemailer transport”](https://www.npmjs.com/search?q=nodemailer%20transport) search query on the NPM registry.

A definite question that always springs to mind is why there are so many email service providers out there and how to choose the one that fits best with your communication strategy. Unsurprisingly, such analysis paralysis is fairly ubiquitous in today’s SaaS world. Calling it a SaaS paradox of choice would hardly be an overstatement. Unless you have theoretically infinite resources at your disposal (read: you’re at a giant like Google or Facebook), these choices can slow down the speed of development significantly and don’t bode well with the “move fast and break things” mantra if you have to go back and forth between email service providers and rewrite your backend stack to accommodate the changeset.

![nodemailer-1](//images.contentful.com/z7iqk1q8njt4/2H94fFdV1jsgw4UVZBHhIv/a9d44c307294b3e2b9b08ac902042415/nodemailer-1.png)
Source: [https://xkcd.com/2224/](https://xkcd.com/2224/)

## Classic build vs buy mindset

In one of our blog posts, we talked about the build vs buy mindset and how it makes a difference, especially if you are a startup - read about it [here](https://www.courier.com/blog/the-three-things-to-never-build-in-your-app/) if you’re curious. The mindset not only makes a difference for your speed of iteration, but also keeps you potentially ahead in the game especially if and when your competitors are adopting buy over build for non-core features of their product. One of the best examples is hosting on AWS vs maintaining on-premises cloud infrastructure - outsourcing cloud hosting to AWS gives you the speed of iteration with no cost of infrastructure maintenance. Imagine all of your competitors are on AWS but you aren’t - it’d certainly make a tremendous negative difference in the long run. While this certainly does not necessarily apply to all the companies out there, it does hold truth for the most. “Disruptive economic events like COVID have caused many people to step back and think about how they want to change strategically. And many have come to the conclusion that they do not want to own and run their own data centers.”, says AWS CFO Brian Olsavsky [https://www.theregister.com/2021/07/30/amazon_q2_2021/](https://www.theregister.com/2021/07/30/amazon_q2_2021/).

An effective communication strategy plays a critical role in maximizing the odds of product success. It's a no-brainer that you have to have a way to reach out to users via Email - but that’s not going to be enough. Customer engagement via text messaging, in-app messaging or direct messaging (think Slack, Whatsapp, MS Teams etc.) has become a necessity in today’s hyper-competitive market. Sooner or later (definitely sooner than you think), having these multiple channels of communication are going to make a difference to your business. As you would scale your product or company, notifications infrastructure has to scale as well in order to handle queuing, scheduling, routing, rendering, and ensuring delivery of messages across multiple channels. Companies like LinkedIn have spent millions to build this infrastructure in-house - depicted quite well in [LinkedIn’s Air Traffic Controller](https://engineering.linkedin.com/blog/2018/03/air-traffic-controller--member-first-notifications-at-linkedin) blog post.

Continuing my mini-rant on the SaaS analysis paralysis, as you’d have probably seen it coming, the paralysis exists on text messaging too - Twilio, Sinch, Plivo and Vonage to name a few providers in the arena. Managing multiple channels and providers to suit the communication strategy you’ve embraced is not a cakewalk. Lets circle back to the never-ending list of email providers and their corresponding Nodemailer transport plugin implementations out there. An easy way to fight the paradox is with a layer of abstraction, such that you can change providers without having to rewrite the code to switch the transport plugins. That’s exactly where Courier comes into picture with its API layer of abstraction and a configurable UI to switch email providers without having to change the code on your end. Needless to say, Courier should expose its own Nodemailer transport plugin which abstracts using a specific email provider plugin. Having this abstraction would imply no vendor lock-in as far as downstream delivery is concerned.

## Show me the code!

Let’s dive right into writing the plugin! [Nodemailer plugin creation](https://nodemailer.com/plugins/create/) (specifically the transport section) and a [Mailgun implementation](https://github.com/orliesaurus/nodemailer-mailgun-transport) would be our reference points. While the core documentation is exhaustive, we’ll keep it relatively simple for the first version of our plugin.

TL;DR: [https://github.com/tk26/nodemailer-courier-transport](https://github.com/tk26/nodemailer-courier-transport) is the code we’ll end up writing.

**Step 1 - Create a new NPM package and adding courier-node as a dependency**

Here's the [Node.js module](https://www.npmjs.com/package/@trycourier/courier) for communicating with the Courier REST API. The source code behind the package is MIT licensed at [courier-node](https://github.com/trycourier/courier-node) repo.

**Step 2 - Configuration prerequisites**

You will need to get a Courier API key to get started. You can sign up and create one for free at [courier.com](https://courier.com). Courier being a middleware, you’d have to configure an email provider of your choice that’d do the actual delivery of the email to the recipient. Stuck in the paradox of choice? We got you! Here’s an [article](https://www.courier.com/blog/best-transactional-email-api-service) we published earlier this year that could be helpful in figuring out. Thereafter, you’d have to create a notification template with email as the channel. [Here’s](https://docs.courier.com/docs/getting-started-sendgrid) how to do it using SendGrid.

**Step 3 - Writing the transport core**

Transports have a **send()** method and **name** and **version** properties. Transport object gets passed to the **createTransport()** method to create the *transporter* object.

    const transport = (options) => {
      const courier = CourierClient({ authorizationToken: options.apiKey });

      const courierSend = input => courier.send({
    	eventId: input.eventId,
    	recipientId: input.userId,
    	profile: {
      	email: input.to,
    	},
      });

      return {
    	name: "Courier",
    	version: packageData.version,
    	send: send(courierSend),
      };
    };

That’s pretty much it for the basic version of the plugin. We’ve pushed the code to [https://github.com/tk26/nodemailer-courier-transport](https://github.com/tk26/nodemailer-courier-transport). feel free to play around with it and reach out with any questions/feedback. It’s open sourced under MIT license so feel free to contribute to the open source project.

**Step 4 - Using the code in your tech stack**

Here’s how things would look in your Node.js backend -

    const nodemailer = require("nodemailer");
    const courierTransport = require("nodemailer-courier-transport");

    // This is your API key that you retrieve from courier.com account (free up to 10k monthly sends)
    const auth = {
      apiKey: "ABCDEFGHIJKLMN",
    };

    const nodemailerCourier = nodemailer.createTransport(courierTransport(auth));

    nodemailerCourier.sendMail(
      {
    	eventId: "courier-event-id", // Configured in Courier UI
    	to: "recipient@domain.com",
    	userId: "unique-user-id",
      },
      (err, info) => {
    	if (err) {
      	console.log(`Error: ${err}`);
    	} else {
      	console.log(`Response: ${info}`);
    	}
      }
    );

Note: We haven’t published the package yet as it is still in a nascent stage. Let us know if you are looking to contribute to the package or want us to publish it so you can use it in your backend. :)

## Key takeaways

Let's summarize the key takeaways from the post. First and foremost - writing and maintaining open source projects that stand the test of time is hard, and projects like Nodemailer are great examples to learn from. Buying over building non-core product features is one of the most important trade-offs you can do to grow your company faster. The sooner you do the trade-off, the higher the returns (and in turn the competitive advantage) you gain. Last but not least, communication strategy is a key pillar in your company’s success - make sure you get it right without compromising on the speed of iteration.

If you’re looking for an easy to integrate, scalable and a reliable communication strategy - sign up for a free [Courier](https://www.courier.com/) account. You build the next big thing and let us handle the communications for you! 🚀


a fish attached to a jet pack speeds past the other fish in the sea

nodemailer-header

We start by diving into Nodemailer and writing a transport layer plugin to switch downstream email service providers by configuration instead of code changes.

How to Send Email with Nodemailer Through Multiple Providers

nodemailer-thumbnail

Nodemailer and the SaaS Paradox of Choice

Riley Profile Picture

Riley Napier

who-knew-email-subjects-header

who-knew-email-subjects-thumbnail

Who Knew Email Subjects Are So Complicated?

the-three-things-to-never-build-in-your-app-header

engineer relaxing while an automated system does all the work

Courier [Integrations]

Courier + Segment Integration: Product Notifications In Minutes

Nodemailer and the SaaS Paradox of Choice

Who Knew Email Subjects Are So Complicated?

The Three Things to Never Build In Your App: Authentication, Notifications, and Payments

Follow These Considerations For An Effective Push Notification System Design

How to Add a Direct Twilio SMS Integration With Sendgrid Emails

Standardizing Message Status Across SendGrid, Twilio, Slack, Firebase, and More

Build your first notification in minutes

Build your first notification in minutes

Product

Developers

Resources

Company