Guide

Tutorial

Product News

Courier Updates

User Experience

Product Management

Integrations

Engineering

Live Streaming

Notifications Landscape

Courier

Raymond See Headshot

Raymond See

You can’t really invest in a data team too early. That’s something we learned as a small but growing team. We invested in a data team at an early stage, so we could establish product usage trends, create business insights, and identify areas to improve our product. 

If you’re an early-stage startup, start building your data strategy team and architecture as soon as you can. You don’t have to go big—a one-person data team can make a massive difference to your success as you grow.

## Hire a Generalist First

When it comes to launching your data team, you might be tempted to hire an expert from the largest brand name you possibly can. Our advice: find someone with early-stage startup experience and has worked with data at scale too.

There are wonderful people with brilliant minds working on large enterprise data teams, but these large teams often have their employees specialize in specific parts of their data platform. That makes sense when you have 10 data engineers on a team or when you have a large team of machine learning data scientists working on pricing algorithms. But when you’ve only got one data role for the entire organization, you need someone who can do a little bit of everything.  

It’s important to first hire an all-rounder who can create data insights, develop business hypotheses, and create a scalable data architecture from scratch. You need someone ready to start building the data team from the ground up, preferably someone who can hire out the rest of your team once you’re ready to do so.

This first hire should be someone who has experience building (or at least working on) a data team at an early-stage startup. They need to be able to generate value quickly and have the business acumen to ask the right questions. They should be able to approach data in an 80/20 manner to deliver immediate results instead of diving into the hardest problems that you have.

For the data engineering side, it’s common to hire a consultant or contractor to help set up your architecture. We decided to complement our first hire with a consultant. This way, we have the best of both worlds – an expert in data engineering part time, and a generalist who can maintain data architecture on a day to day basis. We set up strong foundations and also kept our knowledge in house.

## A Small Data Team Can Answer Big Questions 

Even if you can’t hire right away for all the roles you want on your data team long term, you can do a lot with only one or two of the right people. The key is thinking in terms of scalability and efficiency. What helps your data team do more with less? And how will this work when your team is bigger? 

Scalable analyses are extremely important with a small data team. By thinking ahead about how your processes and workflows will function as your team grows, you’ll save time and create valuable solutions for some of your employees’ most time-consuming issues. 

For example, we immediately realized that our sales team had no visibility into prospective customer product usage, and it was going to come up often. So we built our sales reps a workspace dash so they can pull the data themselves. Our data team’s job is to enable data-driven decision-making. When we saw an opportunity for a one-time data investment that could lead to hundreds of saved hours on the sales side, we acted on it.  

A small data team should also be focused on preventing issues in the future. If you only have the headcount for a one-person data team at the moment, keep them focused on your biggest problems but also budget time to maintain and scale your data architecture to reduce tech debt.  

## The Tools Our Data Team Uses 

From the beginning, our goal was to be forward-thinking with every decision. 

Like all startups, we wanted to generate immediate ROI. We use a centralized data warehouse that is our single source of truth – nothing hurts data teams more than having fragmented or untrustworthy data. We’re able to consolidate our data thanks to automations and integrations. This helps us provide valuable insights to the entire company with low lift.

![Courier Data Pipeline](//images.ctfassets.net/z7iqk1q8njt4/4cl15zd8abN9xXQGiSrGAX/c38faa16b0ef71ee923c344fc266a4c3/image.png)

We pipe in all of our data using ELT tools like [Segment](https://segment.com/) (which is also our data collection tool), [Fivetran](https://www.fivetran.com/), and Snowflake external stages.

[Snowflake](https://www.snowflake.com/) is the brains of the operation, all of our data gets piped there and we use that as our Single Source of Truth. Establishing this single source of truth is critical for ensuring that all of our metrics are the same across all systems. This helps build trust across our stakeholders and makes it easy for us to join data from multiple sources. For example, while feature usage is helpful for us to look at in isolation, combining this with payment data will create insights on what customers are willing to pay for.

We use [dbt](https://docs.getdbt.com/) to clean all of our raw data into a more usable format. For example, our dim_user table has ~20 tables powering it under the hood, that have a lot of critical info on our customers, such as how many notifications they send and what plan type they are on. By making this so readily available, our non-technical users can quickly draw business insights. We can quickly look at non-paying or self-serve customers that are sending a lot of notifications to identify business contract prospects. Our customer success team also built reports to look at the health of our business contract customers. We also use dbt to clean our data of sensitive information.

We use [Census](https://getcensus.com/) to send our warehouse data back to places such as HubSpot and Courier. This allows our sales and marketing teams to access this information on the platform that they are using on a daily basis.

[Metabase](https://www.metabase.com/) is our BI tool. It allows us to create dashboards, write SQL queries, and provide a self-serve format for non-technical users. We’ve found that creating these kinds of self-serve data dashboards allows users to answer a lot of their own questions. They are quick to spin up without large investments upfront like teams that use Looker or Tableau. 

For example, we have a KPI dash that shows the top metrics across the company. We can also track how individual workspaces are performing and identify workspaces that we can target for our sales team. We have also brought data-driven decision-making to our product development by deep-diving into our customers’ product usage. One example is that we found that a lot of our users were creating their own Courier instance instead of joining their colleague’s existing Courier instance. Using this insight, our product team went back to the drawing board to create a page that surfaces Courier workspaces that are created by the same business email domain so you can easily request access. 

![data-courier-workspace](//images.ctfassets.net/z7iqk1q8njt4/3YqJYHW2TZvNZKECRcxRLp/aa3270ad15f19508ccc4163f0eecbcba/data-courier-workspace.png)

We also use [Propel](https://propeldata.com/) to power our in-app analytics to provide visibility for our end users. One way that we use Propel is to deliver template analytics for our Business-tier customers. Propel allows our engineers to easily put GraphQL visualizations on top of our metrics from our warehouse.

![data-courier-analytics](//images.ctfassets.net/z7iqk1q8njt4/21zTz6npIrfOc1bmnswwuq/428adf42da4af54d0389b0899c52f780/data-courier-analytics.png)

[Eppo](https://www.geteppo.com/) is our experimentation analytics platform. The way that they define experiments and relevant metrics makes it really easy to scale experimentation without much overhead – it can take as few as five minutes to setup an additional experiment. Having an integration with our warehouse is key – no longer is experimentation a blackbox, and we get to have our internal data layer for free for us to do deep dives. No longer do you need to go to your data team to ask for specific cuts such as “How is this feature affecting paid vs free users?” or “Do we see differences in the US vs Rest of World?” as you get this out of the box with a few clicks. This unlocks more time for our data team and creates a better experience for our Product, Engineering and Design stakeholders.

## Our Data Team Is Evolving Again

Now, we’re entering a period of growth, so naturally, we’re evolving our data approach again. Our current goal is to enable our data scientists to build subject matter expertise while still maintaining centralized data standards. 

Our current structure is centralized, with a senior analytics engineer reporting to the head of data. It works now since we’re still in the earlier stages of building out a data team. But when the team expands, we will be transitioning to a hybrid model.

Data scientists will cover certain business areas (like the product team), but they’ll still report to the Head of Data. This will allow the data scientists to build subject matter expertise while still maintaining centralized data standards as we continue to grow. Because the data team will always be changing and growing along with the rest of the organization, you need standards that will scale with the business.

If you’d like to learn more about how we approach data standardization, check out our blog post on [how Courier became HIPAA compliant](https://www.courier.com/blog/how-courier-became-hipaa-compliant/).

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!

Book with data flying into/out of it through computers, phones, and other devices.

data-header

How tools like Segment, Metabase, Snowflake, Census, and others, can help establish a data team from the very early stages in a startup.

data-thumbnail

Tools and Techniques to Establish Your Data Team Early

Prakhar Srivastav

Motivational quotes were quite the rage back in the day when MMS & email forwarding were popular. I remember my parents forwarding me at the start of every morning. Fast forward to today, if you are lucky, you are part of some forward group on your messaging app of choice (Whatsapp, Telegram, etc.).

Inspired by the same idea, today we are going to build a service that sends our friends and family an AI generated motivational quote-of-the-day. Rather than hardcoding a list of motivational quotes, we are going to use a machine learning model to generate a quote on demand, so that we never run out of quotes to share!

![QOTD Final Project](//images.ctfassets.net/z7iqk1q8njt4/1R04JX4FjNAccZFLrmr9SF/467f50f89c928e7665e81ee25fb69c19/qotd_pic_1.png)

## Instructions

### Part 1: Using AI to generate motivational quotes

#### OpenGPT2 and Language Models
OpenAI GPT-2 model was proposed in Language Models are Unsupervised Multitask Learners by Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei and Ilya Sutskever. It’s a causal transformer pre-trained using language modeling on a very large corpus of ~40 GB of text data.

To simplify this, at a high level OpenAI GPT2 is a large language model that has been trained on massive amounts of data. This model can be used to predict the next token in a given sequence.

If that sounds too complicated, don't worry, you don't need to know any Machine Learning or AI to follow along with this project. Libraries such as [Hugging Face](https://huggingface.co) make using this model in our app very easy.

#### Hugging Face

We'll use the [Hugging Face](https://huggingface.co/) library to load and serve the ML model that will generate the quotes for us. Hugging Face makes it very easy to use transformer models (of which GPT2 is a type) in our projects without any knowledge of ML or AI. As mentioned earlier, GPT2 is a general purpose language model which means that it is good at predicting generic text given an input sequence. In our case, we need a model more suited for generating quotes. To do that, we have two options:

1. We can fine-tune the GPT2 model by using our own text for which we'll need a good dataset of quotes.
2. Or we can find an *already* existing model which has been fine-tuned with some quotes.

Luckily, in our case there’s a fine-tuned model that has been trained on the 500k quotes dataset - https://huggingface.co/nandinib1999/quote-generator

With Hugging Face, using this model is as easy as as creating a tokenizer

```python
from transformers import AutoTokenizer, AutoModelWithLMHead, pipeline

tokenizer = AutoTokenizer.from_pretrained("nandinib1999/quote-generator")
```

then, constructing a model from the pretrained model

```python
model = AutoModelWithLMHead.from_pretrained("nandinib1999/quote-generator")
```

and finally, constructing the generator which we can use to generate the quote

```python
generator = pipeline("text-generation", model=model, tokenizer=tokenizer)

# use a starting prompt
generator("Keep an open mind and")
[{'generated_text': 'Keep an open mind and a deep love for others'}]
```

#### Building an API to serve the model

Now that we have a way to generate quotes for us, we have to think about how we can use this in our app. There are multiple ways to go about building this.

1. Load the model everytime we want to run the script to send the script.
2. Create an API or service that serves this GPT2 model to generate quotes for us on demand. 

A key plus point of the second option is that once the model is loaded the API can respond to us quickly and can be used in other applications as well. FWIW, the first option is a totally valid approach as well.

We can use [Fast API](https://fastapi.tiangolo.com/) to build a quick serving API. Here's what that looks like

```python

# in file api.py

from pydantic import BaseModel
from fastapi import FastAPI, HTTPException
from transformers import AutoTokenizer, AutoModelWithLMHead, pipeline

## create the pipeline
tokenizer = AutoTokenizer.from_pretrained("nandinib1999/quote-generator")
model = AutoModelWithLMHead.from_pretrained("nandinib1999/quote-generator")
generator = pipeline("text-generation", model=model, tokenizer=tokenizer)

app = FastAPI()

class QuoteRequest(BaseModel):
    text: str

class QuoteResponse(BaseModel):
    text: str

### Serves the Model API to generate quote
@app.post("/generate", response_model=QuoteResponse)
async def generate(request: QuoteRequest):
    resp = generator(request.text)
    if not resp[0] and not resp[0]["generated_text"]:
        raise HTTPException(status_code=500, detail='Error in generation')
    return QuoteResponse(text=resp[0]["generated_text"])
```

Let's test it out

```sh
$ uvicorn api:app

INFO:     Started server process [40767]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```

Now we can start sending requests to the `/generate` endpoint that will generate a quote for us.

![QOTD Part 2](//images.ctfassets.net/z7iqk1q8njt4/1TXDqA7VRfbwZRNDH76Kms/f6cce20ca8d4f5aaa9ecd313976488a3/qotd2.png)

### Part 2: Building the Quote Generator

Now that we have a way to generate quotes on demand, we can stop here and start working on sending this via [Courier](http://courier.com/). But who are we kidding, no one reads text anymore! We can make this interesting by using a nice image and placing our quote on it to make it look like a poster.

#### Generate quote

Given our API, we can now do the following to generate a quote

```py
from random import choice
# feel free to add more starting prompts for more variety
canned_seeds = ["Always remember to", "Start today with", "It is okay to"]
seed = choice(canned_seeds)
resp = requests.post('http://127.0.0.1:8000/generate', data=json.dumps({"text": seed}))
return resp.json()["text"]
```

#### Downloading the background image

The first challenge is getting a beautiful background image for our quote. For that, we'll use the Unsplash API that provides a nice endpoint to return a random image matching a query. Opening https://source.unsplash.com/random/800×800/?nature in our browser returns a nice nature image. 

To keep things interesting, we can use different query terms such as stars, etc. Here's the how the code for downloading our background image looks like - 

```py
from random import choice
image_backgdrops = ['nature', 'stars', 'mountains', 'landscape']
backdrop = choice(image_backdrops)
response = requests.get("https://source.unsplash.com/random/800×800/?"+ backdrop, stream=True)
# write the output the img.png on our filesystem
with open('img.png', 'wb') as out_file:
    shutil.copyfileobj(response.raw, out_file)
del response
```

#### Creating the image with the quote

Ok, now we have our background image and a quote which means we can work on assembling the final image that will be sent to the recipients. At a high level we want to place some text on an image but even this simple task can be challenging. For starters, there are a number of questions for us to answer

1. How will the text be placed on the image?
2. What about wrapping the text?
3. What color should the text be so that it is visible on the background image?
4. How do we do this for images with varying widths and heights?

The answers to some of these questions are more complicated than others. To keep it simple, we'll put the text in the center, and do some wrapping so that it looks good. Finally, we'll use a light color text for now. For all image manipulation, we'll use Python Image Library (PIL) to make this easy for us.

```py
# use the image we downloaded in the above step
img = Image.open("img.png")
width, height = img.size
image_editable = ImageDraw.Draw(img)

# wrap text
lines = textwrap.wrap(text, width=40)

# get the line count and generate a starting offset on y-axis
line_count = len(lines)
y_offset = height/2 - (line_count/2 * title_font.getbbox(lines[0])[3])

# for each line of text, we generate a (x,y) to calculate the positioning
for line in lines:
    (_, _, line_w, line_h) = title_font.getbbox(line)
    x = (width - line_w)/2
    image_editable.text((x,y_offset), line, (237, 230, 211), font=title_font)
    y_offset += line_h
img.save("result.jpg")
print("generated " + filename)
return filename
```

This generates the final image called `result.jpg`

#### Uploading the image
For the penultimate step, we need to upload the image so that we can use that with Courier. In this case, I'm using Firebase Storage but you can feel free to use whatever you like.

```py
import firebase_admin
from firebase_admin import credentials
from firebase_admin import storage

cred = credentials.Certificate('serviceaccount.json')
firebase_admin.initialize_app(cred, {...})

bucket = storage.bucket()
blob = bucket.blob(filename)
blob.upload_from_filename(filename)
blob.make_public()
return blob.public_url
```

## Step 3: Integrating with Courier

Finally, we have everything we need to start sending our awesome quotes to our friends and family. We can use Courier to create a good looking email template.

[Start by creating an account.](https://app.courier.com/signup)

#### Creating the template in Courier

![QOTD Courier Email Template Preview](//images.ctfassets.net/z7iqk1q8njt4/NvMlJ4UVAaWZHzIOooG0P/879d8e96f866f09d7a5d0b582a79562a/qotd3.png)

#### Sending the message

Sending a message with Courier is as easy as it gets. While Courier has its own SDKs that can make integration easy, I prefer using their API endpoint to keep things simple. With my `AUTH_TOKEN` and `TEMPLATE_ID` in hand, we can use the following piece of code to send our image

```py
import requests

headers = {
    "Accept": "application/json",
    "Content-Type": "application/json",
    "Authorization": "Bearer {}".format(os.environ['COURIER_AUTH_TOKEN'])
}
message={
    "to": { "email": os.environ["COURIER_RECIPIENT"] },
    "data": {
        "date": datetime.today().strftime("%B %d, %Y"),
        "img": image_url ## this is image url we generated earlier
    },
    "routing": {
        "method": "single",
        "channels": [
            "email"
        ]
    },
    "template": os.environ["COURIER_TEMPLATE"]
}
requests.post("https://api.courier.com/send", json={"message": message}, headers=headers)
```

The API key can be found in [Settings](https://app.courier.com/settings) and the Template ID can be found in the [template design's](https://app.courier.com/designer) settings. And that's it!

## Conclusions

This tutorial demonstrated how easy it is to get started with machine learning & Courier.

If you want to go ahead and improve this project, here are some interesting ideas to try

- Better background image: Use a term from the generated quote to search for an image?
- Better background color for the text: Use better colors for the text. One cool idea is to use the complimentary color from the image's main color. You can use k-means clustering to find that out.
- Adding more channels : Extends this to messages on messaging clients and sms!

## About the Author

[Prakhar](https://prakhar.me) is a senior software engineer at Google where he works on building developer tools. He's a passionate open-source developer and loves playing the guitar in his free time.

## Quick Links

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

🔗 [Hugging Face](https://huggingface.co/)

🔗 [Fast API](https://fastapi.tiangolo.com/)

🔗 [Unsplash API](https://unsplash.com/developers)

QOTD Header

Courier and OpenGPT2 in action: build a service that sends friends and family an AI generated motivational quote of the day.

QOTD Thumbnail

Develop a Motivational QOTD with Courier and GPT2

shreya-headshot

Shreya Gupta

## Introducing Decode

Your new favorite live coding series is here! We're thrilled to announce the launch of [Decode](https://www.courier.com/events/workshops/)! In this series, we’ll equip backend developers with an expanded knowledge base and skills to build exceptional notification experiences in web and mobile apps and bring together experts in various fields to share their knowledge. Whether you're a seasoned professional or just starting out, these workshops will provide valuable insights and hands-on training on the latest trends and technologies. Read on to learn more about what to expect and how to get involved.

### Ep 1: Automate Push Notifications with Node.js

*February 9th, 2023 @ 10am PST*

Guest Host: Mike Miller, Sr Software Engineer at Courier
This workshop is designed for developers looking to learn how to automate push notifications in web and mobile applications in three steps:
Set up support for push notifications on iOS & Android apps
Create your automation
Link your automation to your server side app in Node.js
By the end of the workshop, attendees will have a solid understanding of sending and automation notifications from Node.js apps and be able to implement their newfound skills in their own applications.
### Ep 2: Reset Password Notifications with Python and Auth0

*February 16th, 2023 @ 10am PST*

Learn how to create secure password reset notifications using Python and Auth0. Attendees will gain hands-on experience integrating Auth0 into their Python applications and implementing password reset flows. Throughout the workshop, participants will learn how to use Auth0's APIs and features to handle user authentication and authorization, and will have the chance to test and deploy their code.

### Additional Workshops Coming Soon!

- Event Driven Notifications with Segment
- Build Transactional Notifications with Node.js and Twilio
- Create an Inbox for User Activity Updates with Python
- Send Scheduled Local iOS Notifications with Swift
- Automate Slack and MS Teams Notifications using Go
- Scheduled and Recurring Email Notifications with Python

## Watch, Develop, and Learn

Unleash your coding skills and join the ultimate tech livestream series of the year! Decode is packed with opportunities to build and showcase your projects. Can’t wait and want to see what Courier is all about? [Sign up for free today.](https://app.courier.com/signup)

[Tune in every Thursday at 10am PST starting next week!](https://www.courier.com/events/workshops/)


Build exceptional notification experiences in web and mobile apps.

Watch, develop, learn!

Cryptex with "Courier" as key and Courier logo in middle.

Decode Launch Header

Live coding workshops to build exceptional notification experiences for developers

Decode Launch Thumbnail

Decode: Live Workshops to Build Exceptional Notification Experiences

Fazza Profile

Fazza Razaq Amiarso

## Background
A lot of open-source invoice management apps are built with Laravel. As a Javascript developer, I wanted to build the “React Solution” for devs that are familiar with React and Javascript.

A problem I found when building with services in Node.js is that there is no built-in mailer. So, I had to find a 3rd party service to do that for me. In this article, I will be integrating [Courier](https://www.courier.com/) to send emails for this project [https://github.com/fazzaamiarso/invoys](https://github.com/fazzaamiarso/invoys).  

## Pre-requisites
As this article isn't your typical follow-along (more like "please sit tight and see how I do it"), it's not mandatory to be familiar with all technologies used. However, familiarity with Typescript and Next.js will be beneficial for quicker understanding.

Technologies in this blog:
- [Typescript](https://www.typescriptlang.org/): type-safety and auto-completion are the best, right? 
- [Next.js](https://nextjs.org/): a production-ready framework to build a full-stack app, even for beginners.
- [Prisma](https://www.prisma.io/): a great ORM to work with databases. We use Prisma because of its type-safety and auto-completion, providing great developer experience with typescript added.
- [Trpc](https://trpc.io/): enable us to easily build end-to-end type-safety between our Next.js client and server.
- Courier API: a great service/platform to handle our notifications, such as email, SMS, and much more.

You can find the full [source code here](https://github.com/fazzaamiarso/invoys/tree/bc231301c92bb07692a3388bb50d76d61603a41f) for reference.

### Goals
Before building the features, let's define our goals.
1. Send invoice link to client's email.
2. Send a reminder a day before an invoice's due date.
3. Cancel an invoice due date reminder when the invoice is already paid.
4. Handling network errors.

### Part 1: Setup Courier Platform
Let's head over to the Courier Dashboard. By default, it's in a production environment. Since I want to test things out, I'm going to change to the test environment by clicking the dropdown in the top-right corner.

> We can copy all templates later to production or vice-versa.

Now, I will create a [**brand**](https://www.courier.com/docs/getting-started/courier-concepts/#brands) for my email notifications.

![go to brand](https://i.imgur.com/1Us0dzC.gif)

I'm just going to add a logo (beware that the logo width is fixed to 140px) on the header and social links on the footer. The designer UI is pretty straightforward, so here is the final result. 

<img src="https://i.imgur.com/sFrofll.png" alt="brand template" width="500px" />

Don't forget to publish the changes.

### Part 2: Send Invoice to Email
Currently, the send email button on the UI is doing nothing.

I'm going to create a `courier.ts` file in `src/lib/` to keep all Courier-related code. Also, I will use [courier node.js client library](https://github.com/trycourier/courier-node) which already abstracted all Courier API endpoints to functions.

Before I build the functionality, let's create the email notification design within Courier's Designer and set up the Gmail provider.

On the email designer page, we will see that the created brand is already integrated. After that, let's design the template accordingly with the needed data. Here is the final result.

<img src="https://i.imgur.com/qFhHvAP.png" alt="email template final" width="500px" />

<img src="https://i.imgur.com/B6vKjpH.png" alt="action button" width="500px" />

Notice the value with `{}` that becomes green, it means it's a variable that can be inserted dynamically. I also set the 'See Invoice' button (or action) with a variable.

Before I can use the template, I need to create a *test event* by clicking the preview tab. Then, it will show a prompt to name the event and set `data` in JSON format. That data field is what will populate the value of the green `{}` variables (the data can be set from code also). Since it's a test event, I will fill it with arbitrary values.

Next, I will publish the template so I can use it. Then, go to send tab. It will show the necessary code to send the email programmatically and the `data` will be populated with the previous *test event* that I created. 

<img src="https://i.imgur.com/PMGcVQq.png" alt="code snippet" width="500px" />

#### Backend
I will copy the test `AUTH_TOKEN` to the `.env` file and copy the snippet to `src/lib/courier.ts`.

```ts
const authToken = process.env.COURIER_AUTH_TOKEN;

// email to receive all sent notifications in DEVELOPMENT mode
const testEmail = process.env.COURIER_TEST_EMAIL;

const INVOICE_TEMPLATE_ID = <TEMPLATE_ID>;

const courierClient = CourierClient({
    authorizationToken: authToken,
});
```

Create a `sendInvoice` function that will be responsible for sending an email. To send an email from the code, I use the `courierClient.send()` function.

```ts
// src/lib/courier.ts

export const sendInvoice = async ({
    customerName,
    invoiceNumber,
    invoiceViewUrl,
    emailTo,
    productName,
    dueDate,
}: SendInvoice) => {

    const recipientEmail = process.env.NODE_ENV === "production" ? emailTo : testEmail;

    const { requestId } = await courierClient.send({
        message: {
            to: {
                email: recipientEmail,
            },
            template: INVOICE_TEMPLATE_ID,
            // Data for courier template designer
            data: {
                customerName,
                invoiceNumber,
                invoiceViewUrl,
                productName,
                dueDate,
            },
        },
    });
    return requestId
};
```

Define types for the `sendInvoice` function.

```ts
// src/lib/courier.ts

interface SendInvoice {
    productName: string;
    dueDate: string;
    customerName: string;
    invoiceNumber: string;
    invoiceViewUrl: string;
    emailTo: string;
}
```

Now that I can send the email, I will call it in the `sendEmail` trpc endpoint that resides in `src/server/trpc/router/invoice.ts`.

> Just remember that trpc endpoint is a Next.js API route. In this case, `sendEmail` will be the same as calling the `/api/trpc/sendEmail` route with `fetch` under the hood. For more explanation [https://trpc.io/docs/quickstart](https://trpc.io/docs/quickstart).

```ts
// src/server/trpc/router/invoice.ts
import { sendInvoice } from '@lib/courier';
import { dayjs } from '@lib/dayjs';

// .....SOMEWHERE BELOW
sendEmail: protectedProcedure
    .input(
        z.object({
            customerName: z.string(),
            invoiceNumber: z.string(),
            invoiceViewUrl: z.string(),
            emailTo: z.string(),
            invoiceId: z.string(),
            productName: z.string(),
            dueDate: z.date(),
        })
    )
    .mutation(async ({ input }) => {
        const invoiceData = {
            ...input,
            dueDate: dayjs(input.dueDate).format('D MMMM YYYY'),
        };

        await sendInvoice(invoiceData);
    }),
```

For those who are unfamiliar with trpc, what I did is the same as handling a `POST` request. Let's break it down.

1. Trpc way of defining **request input from client** by validating with Zod. Here I define all data that are needed for the `sendInvoice` function.

```ts
.input(
    z.object({
        customerName: z.string(),
        invoiceNumber: z.string(),
        invoiceViewUrl: z.string(),
        emailTo: z.string(),
        invoiceId: z.string(),
        productName: z.string(),
        dueDate: z.date(),
    })
)
```

2. Define a `POST` request handler (mutation).

```ts
// input from before
.mutation(async ({ input }) => {
    const invoiceData = {
        ...input,
        // format a date to string with a defined format. 
        dueDate: dayjs(input.dueDate).format('D MMMM YYYY'), // ex.'2 January 2023'
    };

    // send the email
    await sendInvoice(invoiceData);
}),
```

#### Frontend
Now, I can start to add the functionality to the send email button. I'm going to use the `trpc.useMutation()` function which is a thin wrapper of `tanstack-query's `useMutation`.

Let's add the mutation function. On successful response, I want to send a success toast on UI.

```tsx
//src/pages/invoices/[invoiceId]/index.tsx
import toast from 'react-hot-toast';

const InvoiceDetail: NextPage = () => {
    // calling the `sendEmail` trpc endpoint with tanstack-query.
    const sendEmailMutation = trpc.invoice.sendEmail.useMutation({
        onSuccess() {
            toast.success('Email sent!');
        }
    });
}
```

I can just use the function as an inline handler, but I want to create a new handler for the button.

```tsx
//src/pages/invoices/[invoiceId]/index.tsx

// still inside the InvoiceDetail component
const sendInvoiceEmail = () => {
    const hostUrl = window.location.origin;

    // prevent a user from spamming when the API call is not done.
    if (sendEmailMutation.isLoading) return;

    // send input data to `sendEmail` trpc endpoint
    sendEmailMutation.mutate({
        customerName: invoiceDetail.customer.name,
        invoiceNumber: `#${invoiceDetail.invoiceNumber}`,
        invoiceViewUrl: `${hostUrl}/invoices/${invoiceDetail.id}/preview`,
        emailTo: invoiceDetail.customer.email,
        invoiceId: invoiceDetail.id,
        dueDate: invoiceDetail.dueDate,
        productName: invoiceDetail.name,
    });
};
```

Now I can attach the handler to the send email button.

```tsx
//src/pages/invoices/[invoiceId]/index.tsx

<Button
   variant="primary"
   onClick={sendInvoiceEmail}
   isLoading={sendEmailMutation.isLoading}>
   Send to Email
</Button>
```

Here's the working UI.

<img src="https://i.imgur.com/ush8wdI.gif" alt="working ui" width="500px" />

### Part 3: Send Payment Reminder
To schedule a reminder that will be sent a day before an invoice's due date, I'm going to use [Courier's Automation API](https://www.courier.com/docs/automations/). 

First, let's design the email template in Courier designer. As I already go through the process before, here is the final result.

<img src="https://i.imgur.com/4l6shqK.png" alt="payment reminder template" width="500px" />

Before adding the function, define the types for the parameter and refactor the types.

```tsx
// src/lib/courier

interface CourierBaseData {
    customerName: string;
    invoiceNumber: string;
    invoiceViewUrl: string;
    emailTo: string;
}

interface SendInvoice extends CourierBaseData {
    productName: string;
    dueDate: string;
}

interface ScheduleReminder extends CourierBaseData {
    scheduledDate: Date;
    invoiceId: string;
}
```

Now, I add the `scheduleReminder` function to `src/lib/courier`

```tsx
//src/pages/invoices/[invoiceId]/index.tsx

// check if the development environment is production
const __IS_PROD__ = process.env.NODE_ENV === 'production';

const PAYMENT_REMINDER_TEMPLATE_ID = '<TEMPLATE_ID>';

export const scheduleReminder = async ({
  scheduledDate,
  emailTo,
  invoiceViewUrl,
  invoiceId,
  customerName,
  invoiceNumber,
}: ScheduleReminder) => {

  // delay until a day before due date in production, else 20 seconds after sent for development
  const delayUntilDate = __IS_PROD__
    ? scheduledDate
    : new Date(Date.now() + SECOND_TO_MS * 20);

  const recipientEmail = __IS_PROD__ ? emailTo : testEmail;

   // define the  automation steps programmatically
   const { runId } = await courierClient.automations.invokeAdHocAutomation({
     automation: {
       steps: [
         // 1. Set delay for the next steps until given date in ISO string
          { action: 'delay', until: delayUntilDate.toISOString() },

          // 2. Send the email notification. Equivalent to `courierClient.send()`
          {
            action: 'send',
            message: {
              to: { email: recipientEmail },
              template: PAYMENT_REMINDER_TEMPLATE_ID,
              data: {
                invoiceViewUrl,
                customerName,
                invoiceNumber,
              },
            },
          },
        ],
      },
    });

   return runId;
};
```

To send the reminder, I will call `scheduleReminder` after a successful `sendInvoice` attempt. Let's modify the `sendEmail` trpc endpoint.

```tsx
// src/server/trpc/router/invoice.ts

sendEmail: protectedProcedure
    .input(..) // omitted for brevity
    .mutation(async ({ input }) => {
        // multiplier for converting day to milliseconds.
        const DAY_TO_MS = 1000 * 60 * 60 * 24;

        // get a day before the due date
        const scheduledDate = new Date(input.dueDate.getTime() - DAY_TO_MS * 1);

        const invoiceData = {..}; //omitted for brevity

        await sendInvoice(invoiceData);

        //after the invoice is sent, schedule the reminder
        await scheduleReminder({
            ...invoiceData,
            scheduledDate,
        });
    }
```

Now if I try to send an invoice by email, I should get a reminder 20 seconds later since I'm in the development environment.

<img src="https://i.imgur.com/MfwQ6F0.png" alt="with payment reminder" />

### Part 4: Cancel a reminder
Finally, all the features are ready. However, I got a problem, what if a client had paid before the scheduled date for payment reminder? Currently, the reminder email will still be sent. That's not a great user experience and potentially a confused client. Thankfully, Courier has an automation cancellation feature.

Let's add `cancelAutomationWorkflow` function that can cancel any automation workflow in `src/lib/courier.ts`.

```ts
export const cancelAutomationWorkflow = async ({
    cancelation_token,
}: {
    cancelation_token: string;
}) => {
    const { runId } = await courierClient.automations.invokeAdHocAutomation({
        automation: {
            // define a cancel action, that sends a cancelation_token
            steps: [{ action: 'cancel', cancelation_token }],
        },
    });

    return runId;
};
``` 

What is a cancelation_token? It's a unique token that can be set to an automation workflow, so it's cancelable by sending a `cancel` action with a matching `cancelation_token`. 

Add cancelation_token to `scheduleReminder`, I use the invoice's Id as a token.

```ts
// src/lib/courier.ts

export const scheduleReminder = async(..) => {
    // ...omitted for brevity

    const { runId } = await courierClient.automations.invokeAdHocAutomation({
        automation: {
            // add cancelation token here
            cancelation_token: `${invoiceId}-reminder`,
            steps: [
                { action: 'delay', until: delayUntilDate.toISOString() },

    // ... omitted for brevity
``` 

I will call `cancelAutomationWorkflow` when an invoice's status is updated to `PAID` in the `updateStatus` trpc endpoint. 

```ts
// src/server/trpc/router/invoice.ts

updateStatus: protectedProcedure
    .input(..) // omitted for brevity
    .mutation(async ({ ctx, input }) => {
        const { invoiceId, status } = input;

        // update an invoice's status in database
        const updatedInvoice = await ctx.prisma.invoice.update({
            where: { id: invoiceId },
            data: { status },
        });

        // cancel payment reminder automation workflow if the status is paid.
        if (updatedInvoice.status === 'PAID') {

            //call the cancel workflow to cancel the payment reminder for matching cancelation_token.
            await cancelAutomationWorkflow({
                cancelation_token: `${invoiceId}-reminder`,
            });
        }

        return updatedStatus;
    }),
```

Here is the working UI.

<img src="https://i.imgur.com/jnLk4Tg.gif" alt="cancel log" width="500px" />

### Part 5: Error Handling
An important note when doing network requests is there are possibilities of failed requests/errors. I want to handle the error by throwing it to the client, so it can be reflected in UI.

On error, Courier API throws an error with `CourierHttpClientError` type by default. I will also have all functions' return value in `src/lib/courier.ts` consistent with the below format.

```ts
// On Success
type SuccessResponse = { data: any, error: null }

// On Error
type ErrorResponse = { data: any, error: string }
``` 

Now, I can handle errors by adding a `try-catch` block to all functions in `src/lib/courier.ts`.

```ts
try {
    // ..function code

    // modified return example
    return { data: runId, error: null };

} catch (error) {
    // make sure it's an error from Courier
    if (error instanceof CourierHttpClientError) {
        return { data: error.data, error: error.message };
    } else {
        return { data: null, error: "Something went wrong!" };
    }
}
```

Let's see a handling example on the `sendEmail` trpc endpoint.

```ts
// src/server/trpc/router/invoice.ts

  const { error: sendError } = await sendInvoice(..);
  if (sendError) throw new TRPCClientError(sendError);

  const { error: scheduleError } = await scheduleReminder(..);
  if (scheduleError) throw new TRPCClientError(scheduleError);
```

### Part 6: Go To Production
Now that all templates are ready, I will copy all assets in the test environment to production. Here is an example.

<img src="https://i.imgur.com/Mr3bmuH.gif" alt="copy assets to production" width="500px" />

## Conclusion
Finally, all the features are integrated with Courier. We've gone through a workflow of integrating Courier API to a Next.js application. Although it's in Next.js and trpc, the workflow will be pretty much the same with any other technology. I hope now you can integrate Courier into your application by yourself.

Get started now: https://app.courier.com/signup

## About the Author
I'm Fazza Razaq Amiarso, a full-stack web developer from Indonesia. I'm also an Open Source enthusiast. I love to share my knowledge and learning [on my blog](https://fazzaamiarso.me/). I occasionally help other developers on [FrontendMentor](https://www.frontendmentor.io/profile/fazzaamiarso) in my free time.

Connect with me on [LinkedIn](https://www.linkedin.com/in/fazzaamiarso/).

## Quick Links

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

🔗 [Contribute to Invoys](https://github.com/fazzaamiarso/invoys)

🔗 [Invoys Motivation](https://fazzaamiarso.me/projects/invoys)

Abstract bank vault with gold coins and locked up boxes guarded by Courier's logo.

Invoys Header

Invoice management tutorial by Courier community developer

Invoys Thumbnail

How to Send Invoice and Add Payment Reminder in Next.js with Courier API

Aman profile pic

Aman Kandola

How do you fairly compensate your employees for a job well done? It’s a question that often gets ignored in favor of the bottom line and one that not enough companies talk about. 

We’ve never been shy about discussing some of the perks and benefits that come with being a Courier employee, but we’ve never detailed our approach to compensation. It’s time we changed that.

We recently received another round of funding and plan to grow our team quite a bit in the near future. And our compensation policy needs to be organized and fair in order to reach that goal. 

We’ve also officially become a fully remote company. This affects how we fairly compensate employees—do we offer the going rate where our employees live? The going rate of the area where our headquarters is located? Every remote team approaches this issue differently.

Our compensation policy and leveling framework are critical for Courier’s success. Here’s how we make it work. 
## Salaries Stay in the 90th Percentile
Everyone wants to know how much a job pays before anything else. That’s probably never going to change. 

At Courier, we know our employees make this organization a success. And salaries allow our employees to live and enjoy their lives. We also want to attract and retain top talent, so we offer new employees salaries in the 90th percentile of San Francisco’s local market rates. We also keep current employees in the same range to keep turnover low and retain our incredible people.
Our compensation philosophy at Courier has historically been to target the 90th percentile of market rates. That sounds great, but determining exactly what that means isn’t easy. It can be a complicated process, so we’ll walk you through the factors we consider. 
First, market rates vary by location. The 90th percentile for a software engineer in California is different from Kansas. So, even though we’re now a fully remote team that hires employees around the globe, we had to choose a location to base our compensation on. Since we originated in the Bay Area, our employees are compensated based on San Francisco’s local market rates. 
We also consider more factors like the job title and level, as well as our company’s stage—for example, small startups obviously don’t usually pay the same as large enterprises. We are currently in between these two stages, so we need to factor that in while we’re building out our team. We use datasets from our own company history to make comparisons against going rates for similar roles at other organizations.
Obviously, there’s room for error here, and the datasets we use from our own employee history are small. But we find that these factors help us keep the most important elements in mind as we decide on compensation going forward. 
## Salary Bands Help Us Reward Top Performers 
When it comes to employee development and advancement, we want employees to be empowered at Courier. And we want everyone to pursue the track that works for them. Promotions are largely determined by individual performance but not just individual performance. The needs of the team and business as a whole are also large factors in our employees leveling up.
We review compensation for each level and role during the second quarter of each year. And every time we hire for a role, we try to review our compensation banding and update it to ensure we’re truly offering our candidates the 90th percentile of the market rate.
Many of our employees increase their level without becoming managers. We believe that excellence should be rewarded and that not every employee’s career path looks the same. There are many ways to contribute and develop as part of the team at Courier. That’s why we don’t require employees to be on a management track to get to a new compensation level. 
Specific titles and expectations for each employee are decided by each team rather than at the company level. There are some nuances to each role and performance that only a supervisor or other co-worker involved in the day-to-day work can effectively evaluate. That’s why we leave the final say to the supervisors running the team. 
## Additional Benefits Sweeten the Deal
While salaries are very important—we all need to eat—we know it’s not the only aspect of compensation that matters to employees. Other benefits play an important role in attracting and keeping employees. 

We offer unlimited paid time off (that includes vacation time as well as sick days). Of course, we also offer robust medical insurance benefits for employees, including vision and dental. For parents who’ve just welcomed a new child into their home, we offer 14 weeks of fully paid parental leave.

As we mentioned above, we have shifted to a fully remote company, so our employees can work from anywhere. That’s a major benefit that can attract serious talent. The most recent Gallup survey on the issue of remote vs. onsite work found that [34% of employees prefer to be fully remote](https://www.gallup.com/workplace/397751/returning-office-current-preferred-future-state-remote-work.aspx), yet many organizations are still pushing their employees to return to shared offices. As a remote-first company, our potential employees know that we will never force them to go to an office.

To ensure our employees have everything they need in their respective office spaces, we offer a home office stipend. We also pay for a DashPass for all employees to make ordering lunch throughout the week a little more affordable. And on Fridays, we buy our employees lunch just to say thank you and start their weekends on a high note.   
## Company Culture Plays a Big Role in Our Compensation Philosophy
As we define compensation for roles and work to recruit the best employees for those roles, our philosophy keeps us focused on fair compensation and benefits. But we also want to acknowledge that there will always be a subjective element to salaries and the promotion process. This fact often makes people uneasy because it can easily lead to favoritism and competition between teams. In our experience, the best way to avoid that problem is by building a healthy, inclusive work culture. 
Attracting the best employees to your organization and keeping them around requires a space where support and collaboration are normalized. We lead by example and share our leadership's decision-making process when we make big decisions.
What we’ve shared with you is an early framework for Courier. We will continue to iterate on this just like we do with everything else. Expect this to evolve as we grow.
And if you’re interested in learning more, you can read about what it’s like to work at Courier by visiting our [careers page](https://www.courier.com/careers/). 


Abstract illustration of people in tech working together remotely.

Compensation Header

Courier's approach to hiring and compensation.

Compensation Thumbnail

How We Attract Top Talent at Courier

Rodrigo Rojas

If you’ve worked on a digital product, whether as a developer, product manager, or business leader, you know that the most common problems in software development are rarely as straightforward as “bugs.” The root of the problem tends to require a little more trial and error. Using Courier is no different.

In this post, we will discuss example issues around Courier’s Gmail integration and API rate limits, an incomplete data profile, and an incomplete request with Inbox and Toast. We will delve into how such issues can present themselves and how to troubleshoot independently to fix any issues.

##Troubleshooting through trial and error
Just because an issue is complicated doesn’t mean the solution can’t be simple. Developers are constantly bombarded with jargon and terminology that could frighten even those of us who are more technologically-literate. Despite one’s development experience, programmers have learned how to find solutions through trial and error, pattern matching, and dare I say it - googling.

Needless to say, it’s almost seen as a rite of passage in one’s programming journey. In this post, we’re going to tackle some of the most common, yet crucial hiccups our developers and users come across when integrating Courier into their notification infrastructure. If you’ve come across a hurdle, there’s a good chance that someone else has already figured out how to get across.
Gmail integration and API rate limits
Congratulations, you’ve successfully signed up to use Courier and are on your way to sending notifications!

Once you’ve gone through the sign-up process and authorized Gmail to send emails on your behalf, you’ll be able to integrate Gmail as a channel to your email notification templates.

![troubleshooting-1](//images.ctfassets.net/z7iqk1q8njt4/1g07OOQxuofea3C54qAq3m/b19d4ca4f72845f7bb6125f4a299fb25/troubleshooting-1.png)
**Notification looks good, and Gmail is integrated**

### The issue
One recurring issue that has come up with our developers is getting rate limited, i.e [429 errors](https://developers.google.com/gmail/api/guides/handle-errors#resolve_a_429_error_too_many_requests) when sending bulk transactional emails with Gmail integration. It’s understandable, getting 400 response errors isn’t fun. However as developers, Google-fu is one of the many skills required in troubleshooting.

![troubleshooting-2](//images.ctfassets.net/z7iqk1q8njt4/5zwNvASHPgEnFcLxgYqzvi/9f6c7f360a2d1179cc6ad5cc06306fda/troubleshooting-2.png)
**Gmail doesn’t like too many requests**

### The fix
There’s no workaround here. Gmail's API has [limitations](https://developers.google.com/gmail/api/reference/quota) based on per-method quota usage (250 per second with 100 quota points per SEND). Thus, Gmail is really intended for getting started fast, testing, or small-scale sending. This is a great way for you to get comfortable with using Courier and make your first couple of sends.

Our recommendation is to check out [our full list](https://www.courier.com/docs/guides/providers/email/) of email providers and choose the best one that will suit your needs depending on your use case. If your intention is to send bulk emails at once, it would be best to choose a provider that will not rate limit you.

## Incomplete profile data
It goes without saying - Courier has an extensive list of notification providers our users can integrate into their notification infrastructure. Each of these providers have their own requirements for the profile object in the response.

Without a profile in the request, some of your notifications will not be delivered and tell you why in the response that can be accessed from the message logs.

### The issue
You’ve integrated your provider and set a channel to your notification. However, the message logs show an ‘Unroutable’ / ‘MISSING_PROVIDER_SUPPORT’ error in the response. This is strange, since you’ve integrated a provider, created a template, and sent a test event. 

![troubleshooting-3](//images.ctfassets.net/z7iqk1q8njt4/7juxpiwBXgmfZC0XsSgzwN/261de11740e3e188fef4949efbfd29c1/troubleshooting-3.png)
**The best part is that the logs tell you what you’re missing.**

### The fix
This varies by provider and channel, but for some of our most common integrations, i.e - email, the fastest fix to the “unroutable” error is by adding an email recipient to the profile. Courier supports many providers, and you can find each providers’ profile requirements in their respective [integration documentation](https://www.courier.com/docs/guides/providers/). Depending on whether you’re using email, sms, push, etc to send your notifications, you want to make sure to provide a profile that matches the channel’s needs.

![troubleshooting-4](//images.ctfassets.net/z7iqk1q8njt4/4avvH0w94vLFMcPYfK2YZ6/9ba799b301c65aa069656dc83277d03d/troubleshooting-4.png)
**Depending on your channel preference, certain providers have different profile requirements.**

![troubleshooting-5](//images.ctfassets.net/z7iqk1q8njt4/1q0umy3jtHE2mNp0RXCJsI/c6e55b97a295f64ba6889bc4d2287be1/troubleshooting-5.png)
**Having a valid email recipient in the profile will allow your email notifications to be sent.**

In-app notifications require a more detailed profile in the request which will be touched on in the following section.

### Profile exceptions
For argument’s sake, let’s say you’ve integrated [Pagerduty](https://www.courier.com/docs/guides/providers/other/pagerduty/) to send out notifications for your system alerts. In this case, Pagerduty does not require a profile because an event is mapped to Pagerduty services and not to an individual. So in this case, you can leave the profile empty.

## Courier Inbox and Toast incomplete request
So you’ve decided you wanted a more centralized feed of your notifications and implemented Courier’s Inbox feature in your application. Our [demo app](https://reactinappnotification.com/) certainly makes it look good, and with the additional [customization options](https://www.courier.com/docs/guides/providers/in-app/courier-push/#customize) to match the look of your app and brand, how can one resist. And for our developers using non-react builds, we have [embedded integration](https://www.courier.com/docs/guides/providers/in-app/courier-push/#embedded-integration) for you.

![troubleshooting-6](//images.ctfassets.net/z7iqk1q8njt4/1Y5tbTyzf3NAgjCVwJ9yE5/40c67f9bdd722d370dc822f390e97a8d/troubleshooting-6.png)
**The beauty of Toast is that each notification allows developers to communicate a CTA (call to action).**

### The issue
Let’s say you’ve successfully implemented Courier Inbox and Toast in your frontend with the right dependencies, and both Toast and Inbox are children of the [CourierProvider component](https://www.courier.com/docs/guides/providers/in-app/courier-push/#courier-components) in your application. 

Everything looks as it should, and even provided a clientKey as a prop. After being able to send a request and receive no errors in our logs, we see a toast notification pop up in our app, yet if we navigate to our inbox widget, it’s empty.

![troubleshooting-7](//images.ctfassets.net/z7iqk1q8njt4/6NSVLn9vBskvQQ3E20sIFI/46e138c4ebcf0d58326dfaf5a7e33350/troubleshooting-7.png)
**We can see the widget and 2 notifications, but where did our notifications go?**

### The fix
Before we dive into the answer, let’s take a look at a sample send request in this case.

![troubleshooting-8](//images.ctfassets.net/z7iqk1q8njt4/1LivGG1I54eJdGgy6SleKR/38256a835be6d97799dde3e5c9ae0e97/troubleshooting-8.png)
**It’s a subtle oversight, but makes all the difference.**

In order for inbox notifications to persist, we need to add to.user_id in the SEND request along with to.courier.channel.

This is for two reasons:

* to.user_id is used by Inbox to persist notifications.
* to.courier.channel is used by Toast to display your notifications.

Your request/test event should now look like this:

``` javascript
message: {
 to: {
   user_id: “user_id”,
 courier: {
    channel: “user_id”,
  }
```

Once our SEND request includes the above configuration, your inbox messages will persist.

### Side note on dependencies/packages
Our team at Courier is constantly working on making improvements, adding support for new features, and fixing bugs. This includes npm/yarn [packages](https://github.com/trycourier/courier-react) for CourierProvider, Toast, and Inbox.

If you wish to update your dependencies, you can update them simply by changing the package.json to the most current version, and running yarn/npm from the root of your project. We invite you to reach out to support should you have any other questions or if you feel like you hit a roadblock.

## Still have questions?
It’s the nature of the business to always be asking questions particularly in our line of work. This article is merely designed to help answer some of the most common questions we’ve come across with our developers. 

With that said, we believe that in order to make software-to-human communication delightful, there needs to be an open line of communication with developers who have implemented Courier to handle their notification infrastructure. We want you to have as many support options as possible whether it’s self-serve through our [docs](https://www.courier.com/docs/) and [articles](https://help.courier.com/en/), or 1-1 with our engineers and support staff. We’re here to make your Courier experience as smooth as possible! If you’d prefer enterprise-level support, sign up for a [demo request](https://www.courier.com/request-demo/) now!


A robot troubleshoots a machine using an instruction manual

troubleshooting-header

We will discuss examples of issues with Courier’s Gmail integration and API rate limits, incomplete data profiles, and incomplete requests with Inbox and Toast.

troubleshooting-thumbnail

Common Courier Troubleshooting Solutions for Developers

When thinking about handling PII (Personally Identifiable Information) for SaaS companies, standards like SOC 2 compliance and GDPR immediately come to mind. One of the most sensitive types of information for a tech company to handle, however, is actually PHI, or protected health information. To be able to handle this type of data, a company must become HIPAA compliant. 

HIPAA, or the Health Insurance Portability and Accountability Act, regulates the way PHI is collected, processed, stored, and shared in the United States. Protecting PII remains as important as ever to maintain a person’s security and privacy online, but in addition, the improper handling of a person’s health data can actually be dangerous. For example, data concerning a child’s vaccinations that are improperly stored could cause the patient to receive a double dose, no dose at all, or the incorrect vaccine entirely. 

Today, we are excited to announce that Courier is now HIPAA compliant and this post will get into why SaaS companies should be HIPAA compliant, why this is important for our company, and the steps we took to get here. 

## Why SaaS companies should be HIPAA compliant
2020 introduced us to healthcare complexities the likes of which the vast majority of people had never seen within their lifetimes. While the world has experienced health emergencies before, none of this size have landed in our current era of tech expansion. We now have SaaS tech tools to help healthcare providers organize and digitize to provide a higher quality experience for patients, both in-person and online. Even mental health services are now often provided at high volume and quality through online counseling options like [BetterHelp](https://www.betterhelp.com/). 

With the demand for healthcare tech growing and the digitization of medical care expanding, even existing SaaS companies can expect a greater portion of their customer base to deal with PHI, which means that they themselves will need to be equipped to handle this sensitive data. Becoming HIPAA compliant is therefore likely going to be necessary in the near future, if it isn’t already, for many SaaS companies. 

## Why Courier invested in HIPAA compliance
Here at Courier, in particular, we knew from the start that HIPAA compliance would be necessary sooner than later. Courier’s mission is to make software-to-human communication delightful, currently by providing excellent notification infrastructure. We are happy to work with our current set of customers such as [Hospitable](https://www.courier.com/customers/hospitable/) to provide better communication between guests and hosts and [LaunchDarkly](https://www.courier.com/customers/launch-darkly/) to help retain users. Another line of important communication, however, exists between healthcare providers and patients, or with other providers. 

A patient who could receive notifications about blood test results, for example, could access their data more easily through a HIPAA-compliant Courier instead of having to deal with terrible UX to get the information they would be waiting for. Other notifications that would require HIPAA compliance include reminders for doctor’s appointments, flags that prescriptions are ready for pickup, and as a more timely example, notifications for Covid test results.   

## Courier’s journey to compliance
To become HIPAA compliant, we had to consider two major parts of the process of handling PHI: who all will be touching the data and how it will be presented in the product. 

For any technical product, data must go through several touchpoints, often repeatedly. PHI collected from a user, for example, would reach our sub-processors in addition to our own databases along with those of our customers who are collecting the data itself. To maintain the integrity of HIPAA as this data moves around, every organization involved signs a BAA, or Business Associate Agreement. According to the U.S. Department of Health & Human Services, a business associate is any person or entity that performs certain functions or activities that involve the use or disclosure of protected health information on behalf of, or provides services to, a covered entity. For Courier, this includes all our vendors, including AWS, for example. 

In terms of how PHI would be presented in the product, we thought about this as an engineering issue from the start. HIPAA applies to communication just like stored data and by nature of how Courier works, that means that the amount of PHI stored for a particular user will only increase rapidly over time. This means that the way data is accessed needs to be considered while designing the product itself. 

As an example, employees of Courier’s customer companies can generally see logs of notifications with their end users to help them gather data to improve their notification strategy over time. However, if a Courier customer is HIPAA compliant, their employees should not have access to their end users’ PII. In this situation, Courier must provide customers with the right tools to manage which employees can access which types of data. This is something to consider particularly carefully if you are an engineer at a SaaS company who is building a notification infrastructure in-house instead of using a tool like Courier - the complexity of building the infrastructure compounded with figuring out how to handle the data in a way that would be HIPAA compliant would be a massive undertaking that is best mitigated by early design considerations around data collection and logging. 

As the engineering team hammered out the best way to handle how the data is compiled and logged, we also needed to make sure to have internal policies designated around PHI as well as processes to implement security safeguards, conduct risk assessments, and handle documentation.

## Conclusion
After this full process, we are happy to announce that Courier is now fully HIPAA compliant, which applies to all U.S. PHI.  To learn more about how Courier approaches security, check out this [series of articles](https://www.courier.com/blog/security-for-your-saas-communications/). If you’re looking for HIPAA compliant notification infrastructure for your own organization, [check out Courier here](https://app.courier.com/signup). 


A doctor sends a pigeon correspondence, representing Courier, to a patient in a different part of the city.

hipaa-announcement-header

This post will get into why SaaS companies should be HIPAA compliant, why this is important for Courier, and the steps we took to get here. 

Courier [Courier]

Build your first notification in minutes

Build your first notification in minutes

Platform

Use Cases

Explore

Company