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!


Request a demo of Courier's business tier today to learn more!

Prefer enterprise-level troubleshooting support?

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

Aman profile pic

Aman Kandola

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). 


If you’re looking for HIPAA compliant notification infrastructure for your own organization, check out Courier!

Are you looking to be HIPAA compliant?

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. 

hipaa-announcement-thumbnail

How We Became HIPAA Compliant

nat-headshot

Nathalia Sandoval

In my first interview with Courier, when my now-boss was telling me about the company, he stopped and said, “I see your display name is not the same as the name on your application. Are there any other pronouns that I should be using?” It was a small gesture, but it made an impact on me. The moment hinted at a company culture built around treating people with respect and appreciating authenticity. Courier is still a very small company building the foundation of a diverse team, but even as we grow, I’m confident that this will remain a priority for us in the future. 

Encouraging employees to be their true selves in big and little ways is important because it’s the right thing to do—it also happens to be the best way to recruit a diverse team of employees. And increasing diversity improves many facets of an organization: Productivity, profits, employee retention, and even the ability to navigate conflict.

In honor of Pride month, let’s talk about the power of diversity and how tech companies should improve inclusion in their organizations.

## Diverse Teams Make More Money
It doesn’t matter whether you’re talking about racial diversity, gender diversity, or other forms of diversity—people with different experiences often come up with different ideas from each other. Those unique insights drive innovation and better decision making, which, in turn, increases profits.

When looking at your demographics, it’s important to consider power and hierarchies. If most of your diversity is at the entry-level while management and leadership remain primarily white, cis, able-bodied, and male, you aren’t going to see the same results as companies with diversity at every level. [Organizations with above-average diversity in management see 19% higher innovation revenue](https://www.bcg.com/en-us/publications/2018/how-diverse-leadership-teams-boost-innovation) than companies with below-average diversity in management. The same study found that teams with above-average diversity in management also had [EBIT](https://www.investopedia.com/terms/e/ebit.asp) (Earnings Before Interest and Taxes) margins that were 9% higher than organizations with below-average diversity in management.

Studies that zero in on the results of increased diversity when it comes to specific demographics see interesting results too. A study that compared two genders (men and women) found that companies where [30% or more of their executives were women](https://www.mckinsey.com/featured-insights/diversity-and-inclusion/diversity-wins-how-inclusion-matters), outperform their peers. Unfortunately, the study didn’t acknowledge or account for other genders.
Available research indicates these results apply to LGBTQ+ diversity as well. A study of the LGBTQ+ inclusivity at 657 publicly-traded U.S. companies found strong evidence that “[more LGBT-friendly firms have higher profitability](https://onlinelibrary.wiley.com/doi/10.1111/acfi.12787) and higher stock market valuations.” Diversity makes sound commercial sense.

## Differences Improve Collaboration and Innovation
Diversity also affects how teams collaborate and innovate in complex ways. Overall, the more diverse a team is, the more creative and innovative they’ll be. Mixed-gender teams can [better manage group conflict](https://www.sciencedirect.com/science/article/abs/pii/S0749597816302205) compared to homogenous teams and can better maximize creativity among team members.

But some situations can thwart the benefits diversity brings. For instance, [stress makes people in groups start leaning back into homogenous thinking](https://onlinelibrary.wiley.com/doi/10.1002/job.2630?af=R). In turn, this can discourage employees who belong to marginalized groups from speaking up. Because these insights are no longer being shared, the benefits of diversity are lost, while employees feel detached and alienated. 

It’s also important to remember that employees who experience oppression are more likely to burn out. Glassdoor reviewed 209,112 workplace reviews and found that [LGBTQ+ employees are 51% more likely to report burnout](https://www.glassdoor.com/research/pride-month-2022/) than their coworkers. A 2021 McKinsey report shared that LGBTQ+ women, disabled women, and Black women [experienced more microaggressions](https://www.mckinsey.com/featured-insights/diversity-and-inclusion/women-in-the-workplace) than their peers and noted that, “Women who regularly experience microaggressions are…almost three times as likely to say that in the past few months they have struggled to concentrate at work as a result of stress.”

In other words, if you want to experience the benefits of diversity, you must create a place where people can genuinely let their guard down and be themselves. That means increasing diversity in your team so employees don’t feel tokenized. This also means making your workplace a safe place to be a marginalized person. How do you do that? By making it an unsafe place for discrimination and harassment. For instance, leadership and management need to step in and say something when they see a microaggression happening. They need to make it an uncomfortable place to foster exclusion and hate.

Harvard Business Review and Glassdoor partnered up for a series of [studies on diversity in the workplace](https://hbr.org/2020/01/the-new-analytics-of-culture) and published an article on their findings in 2021. The author recommends “encouraging diverse cultural ideas while fostering agreement among employees about the importance of a common set of organizational norms and beliefs.” 

## Inclusivity is a Major Factor in Employee Retention
Organizations looking to reduce employee turnover should consider that the level of inclusion employees feel at work greatly influences their career decisions. Whether or not your employees decide to take another job could come down to how comfortable they feel at work.

A survey of 1,789 full-time U.S. employees and 2,000 live participant experiments found “high belonging was linked to a [whopping 56% increase in job performance](https://hbr.org/2019/12/the-value-of-belonging-at-work), a 50% drop in turnover risk, and a 75% reduction in sick days. For a 10,000-person company, this would result in annual savings of more than $52M.”

A 2020 Catalyst survey of 2,100 employees at large corporations found that [35% of an employee’s emotional engagement in their job](https://www.catalyst.org/wp-content/uploads/2020/03/Getting-Real-About-Inclusive-Leadership-Report-2020update.pdf) and 20% of an employee’s decision to stay or leave their current organization is determined by inclusivity.

That’s not  surprising, given that feeling included at work is likely to make people happier, and happier employees are more likely to stay. What’s more interesting is that the retention benefits go beyond the demographics most affected. Workplaces with more gender diversity [may see lower turnover](https://journals.sagepub.com/doi/full/10.1177/0170840619875480) in women and men. (Unfortunately, the research on inclusion didn’t include nonbinary employees.)

## 4 Tips for Increasing Employee Diversity 
To get these benefits, organizations need to clarify where they stand on diversity at every stage of the hiring process. Candidates who are most likely to improve the diversity of your organization will also be looking most carefully at how you talk about and approach diversity.

### 1. Assume many of your LGBTQ+ employees aren’t out at work
The Williams Institute at the UCLA School of Law surveyed 935 adults who identified as “LGBT” in May 2021. They reported that [50% of LGBT employees aren’t out to their supervisor](https://williamsinstitute.law.ucla.edu/publications/lgbt-workplace-discrimination/), and 25% aren’t out to anyone at work. That’s likely because 45% of LGBT employees have already experienced unfair treatment at work at some point in their lives. Keep in mind that many employees will be reluctant to be themselves due to past experiences.

It’s your job to make your organization's culture so welcoming and authentic that employees feel comfortable enough to be themselves. Have leadership and management start putting pronouns in their bios. Don’t invest in anti-LGBTQ+ companies or donate money to anti-LGBTQ+ politicians. Bring in diversity and inclusion educators from the communities they teach about. Never stop actively working to improve your organization’s diversity and inclusion.

### 2. Understand no marginalized communities are a monolith
 Oppression and inclusivity are not simple things. Especially at work. A Catalyst report on inclusivity put it well: “[Employees' work lives are often affected by their experiences as people with intersectional identities](https://www.catalyst.org/wp-content/uploads/2020/03/Getting-Real-About-Inclusive-Leadership-Report-2020update.pdf) such as gender, race, ethnicity, religion, age, LGBTQ+ identity, etc. More granular views of employee experiences of inclusion are needed to truly make an impact.” The report advises organizations to avoid tokenizing employees and build inclusivity into the company culture so it goes beyond policies.
Review your diversity and inclusion strategy and tactics. How is intersectionality addressed in the way you approach diversity and inclusion? If you don’t know the answer, bring in a dedicated diversity and inclusion educator to help you learn more and build intersectionality into your approach.

### 3. Don’t justify why diversity is vital to your organization
Organizations that trip over themselves to explain they’re inclusive because it’s good for business risk alienating potential employees. Research shows employees are more likely to view an organization favorably if they make it clear to potential employees that [honoring diversity is at the core of the business](https://hbr.org/2022/06/stop-making-the-business-case-for-diversity) and avoid any urge to explain why. For example, instead of saying. “We value diversity because it benefits us as well as our employees,” you could say something like, “Honoring and respecting employee diversity is and will continue to be a core value here.”

### 4. Take action
To impact future and current employees, you need to do more than learn and communicate; you’ll also need to take action. Think in big and small ways, such as ensuring health insurance covers gender-affirming care and encouraging employees to add pronouns to bios and email signatures. Ultimately each decision adds up to a culture that either helps employees thrive or holds them (and you) back.

You should prioritize diversity for your organization because it’s the right thing to do. If you can build an inclusive environment where employees like me can be their real selves, every part of the business will benefit, too.
All this is not to say that Courier has mastered building a diverse LGBTQ+ team (or will be able to do so in the near future), but we’re definitely taking a whack at it and I feel confident that we’ll get pretty close. To be a part of this mission, come [join the team](https://jobs.lever.co/trycourier)!


Mother duck swimming with her pride colorful babies in a pond surrounded by tall grass and a setting sun

pride-hiring-2022-header

In honor of Pride month, let’s talk about the power of queer diversity and how tech companies should improve inclusion in their organizations.

pride-hiring-2022-thumbnail

How LGBTQ+ Diversity Builds Better Companies

Troy's Avatar

Troy Goode

We’re excited to announce that we’ve raised $35M to provide engineering teams with fantastic notification infrastructure! The round was led by GV with participation from our existing investors at Bessemer Venture Partners and Matrix Partners.

*“Courier is building the future of notification infrastructure. The company has a fast-growing set of customers with a need to provide the best possible notification experience. GV is thrilled to lead Courier's Series B and partner with Troy Goode and the entire executive team as they deliver on an unparalleled approach to software notifications."* - Sangeen Zeb, GV

Courier’s vision is to be a single source of truth of all of the end-user’s notifications. We aim to bring together all notifications, whether they may be from mobile, email, Slack, or any other channel, to a single point of easy access to lift the burden of improving the notification experience from the end-user. 

The next incremental step on this road is to begin to improve mobile notifications. According to a Courier survey of 157 notification recipients, respondents are more likely to engage with a smartphone notification than a text, email, push, or in-app notification. Our first goal for our Series B, therefore, is to improve the user experience of mobile notifications and we are starting down this path today by announcing new advanced mobile notification capabilities for our platform.  Check out the video below to learn more about our new mobile offerings!

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

## A new category of software: Notification Infrastructure
Every piece of software in the world sends notifications, and just about every software team has had to build the infrastructure needed to deliver those notifications in-house. This ubiquitous need for notification infrastructure demands its own category of software, which gives developers the option to use a third party API instead of building an entirely new notification system from scratch. 

As a former engineer and engineering executive, I’ve experienced the pain involved with building and scaling notification infrastructure too many times. Every time I was tasked with building a new notification system for a new product, I wished there was a service I could reach for to free up my engineering team and avoid the future headache that I knew would follow.

The lack of this type of solution is what drove me to found Courier. 

Courier delivers notification infrastructure to our customers as SaaS. At the center of our product is an API designed for engineering teams. This API allows developers to send notifications across any channel as well as manage user data, preferences, notification workflows, and more. In addition to the API, we provide a web Studio that allows our customers to easily design omni-channel notifications, view logs across notification channels, and providers, as well as visually build out notification workflows.  

We’ve come a long way over the last three years, both as a company and a product, thanks in large part to our customers. Courier is used by hundreds of fantastic software companies such as New Relic, LaunchDarkly, Lattice, and Uservoice. These companies have partnered with Courier to deliver a better product experience to their users while dramatically reducing the amount of time and money spent on building and maintaining their own internal notification infrastructure.

*“Before Courier, we were spending tons of time integrating with every delivery platform every time a customer requested a new connection from us. But now it’s as easy as making an API call. So, so excited about this launch. Huge congratulations to the Courier team!”*  - Eric Koslow, CEO, Lattice

## What’s next: notifications that delight, not distract 
Product notifications are one of the rare parts of software that affect nearly everyone on earth. If you use the internet for work, to buy flights, to network, or to do just about anything else, you receive notifications from that software. 

At their worst, product notifications are annoying, distracting, and anxiety inducing. They can come through different channels from text to email to mobile notifications - or from all of them at the same time, acting as a constant disrupter in the user’s life. At their best, product notifications deliver a delightful experience and make sure that we’re aware of key events that might help catch a flight, meet a deadline at work, or connect with a loved one. In other words, they provide useful interruptions that improve the user’s life.

We will use this new capital to continue to invest in our core mission of making all product notifications delightful, starting now with mobile. What that means today is delivering an amazing toolset to the builders, product and engineering teams, who are in charge of developing product notification systems for their apps. We believe that just about everyone in these roles wants to deliver great notifications with excellent user experience, and that the better the tools and resources at their disposal are, the more able they will be to accomplish this. 

## Introducing Courier’s new mobile capabilities
Today, we’re announcing a new set of two tools and resources for product builders to deliver delightful notifications for their mobile applications. Mobile notifications are the most ubiquitous type of notifications and the one with most potential to annoy users. One annoying notification experience can result in a user turning off notifications altogether, which greatly reduces both the utility and engagement of any mobile application.

The first is our new mobile SDK. This SDK makes it easier for developers to manage push tokens across devices and operating systems. This gives developers better control and visibility, making it easy for them to deliver a more consistent and customized experience for their users based on the best way to reach and engage their users for their specific app. Here’s an example:

``` json
// Register multiple devices for a given user. Notifications will be delivered to each 
// device in a single send call.

{
  "tokens": [
    {
      "token": "abc123",
      "provider_key": "apn",
      "properties": {
        "test": true
      },
      "device": {
        "app_id": "com.my.app",
        "platform": "iOS",
        "model": "iPhone 13"
      }
    },
    {
      "token": "cba321",
      "provider_key": "firebase-fcm",
      "tracking": {
        "ip": "127.0.0.1",
        "lat": "0.0",
        "long": "123"
      }
    }
  ]
}

```

The second is our new mobile notification inbox. This inbox can be easily integrated with any mobile application, and gives the user a central place to view notifications, even if they have disabled push notifications. This gives the end user the ability to better customize their experience using an app by deciding when to access notifications, thereby reducing the number of interruptions mobile notifications cause in their daily lives while increasing engagement with the notifications developers deem necessary to use the product properly.

Visit this page to learn more about this new mobile functionality and request a demo and checkout this video of me demoing them below.

## Conclusion: The work is just beginning
Our mission to make notifications delightful is a big one and there’s still a ton of work to do. We could not have made it to where we are today without all of our fantastic customers, New Relic,  LaunchDarkly, Lattice, Color Health, and many others who share our belief in the value of delivering a great product notification experience. This new funding presents a great opportunity to achieve this ultimate goal. Get a demo [here](https://www.courier.com/features/mobile/) to learn more about Courier’s goals for mobile notifications!

If you are interested in helping to build the future of notification technology starting with mobile channels, we are [hiring](https://jobs.lever.co/trycourier)!


Would you like to meet with a product expert?

A Courier pigeon is propelled forward by the energy from a rocket labeled GV.

series-b-header

We’re excited to announce that we’ve raised $35M to provide engineering teams with fantastic notification infrastructure! Read this to learn all about it!

A Courier pigeon is propelled forward by the energy from a rocket labeled GV

series-b-thumbnail

Courier Raised a $35M Series B to Make Notifications Delightful

nick-headshot

Nick Gottlieb

We’re excited to announce a powerful new feature for the Courier platform: Courier Automations. Courier Automations is a toolset that includes both an API and a visual builder that allows anyone to easily configure logic for notification workflows. Need to send a reminder to class attendees 10 minutes before the class starts? Need to page an on-call engineer on multiple channels until they respond? These use cases and more can be achieved quickly and easily with Automations. 

## Why we built Automations
As developers, notifications are the primary way that the applications we build communicate with our end-users and the use cases vary widely. Some use cases are very straightforward and simply require that a single message goes to a single user once. Many notifications however require more sophisticated orchestration in order to deliver the desired user experience. Most developers today end up building a separate service to manage this logic. This results in additional infrastructure and development overhead and often in a less than ideal end-user experience. 

We built Automations so that developers can deliver the ideal notification experience without needing to build and maintain yet another service.

## What are product and engineering teams doing with Courier Automations today?

While today marks the official release of Automations, many of our customers are already using Automation to power key parts of their product experience.

The engineering team at [LaunchDarkly](https://launchdarkly.com/), a feature management platform, uses Automations to define the logic for notifications associated with approvals for their customers' feature releases. Any time approval is requested or granted, an Automation is triggered to ensure all the relevant stakeholders are alerted. You can read more about their use case here.

[Officevibe](https://officevibe.com/), which is an employee experience platform, regularly sends out Slack notifications on behalf of their customers asking employees to complete a brief survey. Their engineering team utilizes the Automations API to create lists of users for whom the Slack survey could not be delivered and send them an email survey instead. 

For [Yoga International](https://yogainternational.com/), an online Yoga platform, it's essential that they deliver a seamless experience to their customers from the time they register for a live class through to the start of class. Their engineering team utilizes the Automations API to send timely reminders to class attendees for each live class that happens on their platform.

## “Meetings Reminder”
Let's build a meetings reminder that sends an email reminder 10 minutes before the meeting and a link to the meeting notes two hours after the meeting.

**Design the Messages:**
1. Log into [Courier](https://app.courier.com/) and navigate to the [Notifications Designer](https://app.courier.com/designer/notifications)
2. Design an email reminder that will  be sent 10 minutes before the meeting with the Gmail provider (or any email provider of your choice)
![announcing-courier-automations-1](//images.ctfassets.net/z7iqk1q8njt4/2di1jnFJgbxPu9FRtn1xDg/edd5e62f03fda896df4139b1a1868f2d/announcing-courier-automations-1.png)
3. Access the template ID in the settings of that notification and save it for future reference
4. Design an SMS reminder that will be sent two hours after the meeting with the Twilio provider (or any email provider of your choice)
![announcing-courier-automations-2](//images.ctfassets.net/z7iqk1q8njt4/5T0R822GmEl85UJjpxTT8z/32a31f01a4533dceac58da99e62e7f87/announcing-courier-automations-2.png)
5. Access the template ID in the settings of that notification and save it for future reference

### How To Create an Automation Using the API (Node.js Example)

1. Within your Node.js app, install [node-fetch](https://www.npmjs.com/package/node-fetch)
	`npm install node-fetch`
2. Navigate to the [Automations API Reference](https://www.courier.com/docs/reference/automation/invoke/) and copy the starter code
3. Add an `automations` object with an array of objects called `steps`

```json
"automation": {
  "steps": [
    {
      "action": "send",
      "template": "template_id",
    }
  ]
},
```

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

[Automations Docs](https://www.courier.com/docs/guides/tutorials/how-to-automate-message-sequences/)
4. For this example, we will need three steps: send, delay, and another send. The first send step will send the 10 minute reminder. The delay step will wait for two hours after the meeting. The third step will send an SMS with a link to the meeting notes.

```json
"automation": {
  "steps": [
    {
      "action": "send",
      "template": "template_id_1"
    },
    {
      "action": "delay",
      "duration": "130 minutes"
    },
    {
      "action": "send",
      "template": "template_id_2"
    }
  ]
},
```

5. Update `template_id_1` with the notification template from Step 3 of “Design the Message” and update `template_id_2` with the notification template from Step 5 of “Design the Message”
6. Update the `brand` and `recipient` attributes with your preferred [brand](https://app.courier.com/designer/brands) and [recipient](https://app.courier.com/users) IDs
7. If your steps reference any Notification Templates, update the ID `template` attribute
8. Run your code to trigger the Automation

```js
// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');

const options = {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer replace-token'
  },
  body: JSON.stringify({
    "automation": {
      "steps": [
        {
          "action": "send",
          "template": "template_id_1"
        },
        {
          "action": "delay",
          "duration": "130 minutes"
        },
        {
          "action": "send",
          "template": "template_id_2"
        }
      ]
    },
    "brand": "W50NC77P524K14M5300PGPEK4JMJ",
    "template": "EXAMPLE_NOTIFICATION",
    "recipient": "8ec8c99a-c5f7-455b-9f60-8222b8a27056",
    "data": {
      "name": "Jane Doe",
      "age": 27
    },
    "profile": {
      "phone_number": "2025550125",
      "email": "hello@example.com"
    }
  })
};

fetch('https://api.courier.com/automations/invoke', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));
```

9. Check the [Datalog](https://app.courier.com/logs/automations) for delivery status and error messages

### How To Create An Automation Using the Studio
This example demonstrates integrating an API V2 notification send call (Step 5 of "Design the Message").

1. Navigate to the [Automations](http://app.courier.com/automations) page
2. Create an Automation Template from scratch
![announcing-courier-automations-3](//images.ctfassets.net/z7iqk1q8njt4/RjqcqLCVNS9lfXujVjfYi/53e5ac9daa1c3bd6127cd12d31240d98/announcing-courier-automations-3.png)
3. Add a send step and select the “10 minute reminder” for the Notification
![announcing-courier-automations-4](//images.ctfassets.net/z7iqk1q8njt4/376Kg67N5NuoSnRFYkVMD2/d215697c258a3f184426eae7a0acc2ec/announcing-courier-automations-4.png)
4. Add a delay step and update the length to 130 minutes
5. Switch over to code mode (top right, under the the “Publish Changes” button) and add an API V2 notification send call for the SMS with a link to the meeting notes

```json
{
  "action": "send",
  "message": {
    "to": {
      "email": "example@email.com"
    },
    "content": {
      "title": "Meeting Notes",
      "body": "Link to meeting notes: ..."
    }
  }
}
```

![announcing-courier-automations-5](//images.ctfassets.net/z7iqk1q8njt4/5tHxpIlEfnpIxdYADaM9mk/cda00d734408dde76ef31a4ada77765e/announcing-courier-automations-5.png)
*This step can be done within the designer by following Step 3*

6. Select a trigger for the Automation (if no trigger is selected, the Automation can be triggered manually with a curl command)
7. Publish changes to save your Automation
8. Create a Test Event to test your Automation

```json
{
  "data": {},
  "profile": {
    "email": "example@email.com",
    "name": "Your Name"
  }
}
```

![announcing-courier-automations-6](//images.ctfassets.net/z7iqk1q8njt4/1wvA9W2yUDxkEZj6os4yNA/ace96c64264543efaa8a78099cc9b241/announcing-courier-automations-6.png)
9. Invoke your Automation in the Designer or copy the starter code and run it in a terminal

## Getting Started
[Sign up for a free Courier account](https://app.courier.com/signup) to get started with Automations. Courier’s Free Tier includes Automations and up to 10,000 notifications per month.

Learn about how Courier might be able to help you reduce engineering complexity and deliver a better, more engaging notification experience.

Speak with a notifications expert

Several people receive messages by courier pigeon at exactly the same time

automations-announcement-header

Courier Automations is a toolset that includes both an API and a visual builder that allows anyone to easily configure logic for notification workflows.

automations-announcement-thumbnail

Announcing Courier Automations: Application Logic for Notifications

vahagn-headshot

Vahagn Aharonian

It requires an ample amount of time, effort, and resources to produce great, user-friendly documentation. Good documentation is fundamental to the way engineers get started with a product and ultimately use it in the long run, which makes it essential to both user retention and growth. Building our documentation at [Courier](https://www.courier.com/) was a task we therefore took very seriously.

We originally created our documentation for a very small, specific audience with specific uses for Courier. Over time, however, our user base, their use cases, and our product itself has grown dramatically. To cover our bases, we needed to improve and expand our documentation and this time, we wanted to make it scalable and with a focus on a great user experience. We decided to use [Docusaurus](https://docusaurus.io/) to do so, which allowed our engineers to collaborate and update our documentation more efficiently. Here’s how we built our documentation and what we learned in the process that might be useful to you. 

![built-our-docs-1](//images.ctfassets.net/z7iqk1q8njt4/5rCidPNvia7pzkFHRThDWg/0eee977765165d61b895bf2aac459ef0/built-our-docs-1.png)

## Identifying challenges with our documentation process
When we first started Courier, we just wanted [documentation](https://www.courier.com/docs/) that explained how to use Courier as a product. So, we found a tool that could help with that: ReadMe. 

ReadMe gave us enough features to get started with our documentation. We could create and update our documentation when needed and without much effort, but we couldn’t collaborate as much as we needed and could only save one draft at a time. This was a major challenge because anyone could easily overwrite another’s work if they were working on the same file at the same time. ReadMe also had a flat file structure which was inconvenient to use. There was also no real [Git](https://git-scm.com/) integration into their CLI, so we had issues with document versioning and collaboration. Ultimately, this meant that docs were in the approval process for an unnecessary length of time and not everyone was able to make suggestions for improvement as they came up.

So some years and a few significant product updates down the line, we knew that it was time for a major documentation update. ReadMe was easy to get started with and served us well for our first couple of years, but we needed something that addressed our more specific pain points.

## Prerequisites for a documentation tool
So we knew we needed something new. The next step was to decide which solutions were necessary to address our pain points for the next version of our documentation. The team came up with a list of requirements for documentation tools we would use in the future.

### Limitless Collaboration
A happy challenge with a growing company is the need to scale almost every aspect of it as the team and product grow. As Courier’s technical team grows, we have more subject matter experts to provide input on documentation, which is good news for the quality of docs. However, more SMEs mean that we need more people to be able to collaborate on a draft at a time. Since the team will only continue to grow from here, limitless collaboration was one of the basic necessities for our future docs tool(s).

### Versioning
A growing company comes with the inevitability of a growing product. As new versions of the product are released, there will always be an overlap time when some of our users are using an older version of the product and some are on the newest version. Our documentation needs to cater to both of these groups of users, which means to make sure everyone has the correct information, versioning is an important docs feature. For example, we need to keep the documentation of our API 1.0.0 version separate from the one for API 2.0.0 and ensure that it is possible to update and switch between versions quickly and easily.

Version was also important to allow for the option to separate and store drafts away from the official documentation so that the team would be comfortable working without the pressure of a breaking change. 

### Link Validation
One of the worst things that can happen to user experience in product documentation is for a user to click on a link and get a 404 error. It makes it more difficult to keep users in the docs and following instructions, which can ultimately affect how many users successfully get started with the product and/or are able to troubleshoot on their own. A docs tool that would include link validation for internal links would go a long way toward avoiding damaging errors and UX issues.

### Localization 
We have customers from different ethnic groups all around the world who speak a diverse set of languages. To cater to a global audience, users need to be able to read our documentation and get the help they need, regardless of the language they speak. Localizing our documentation like link validation, improves user retention and UX.

## Docusaurus matched our list
With our list in place, we were able to begin researching to find the right new tool. After some research, we discovered that [Docusaurus](https://docusaurus.io/), which is built on React, allowed for limitless collaboration, versioning, link validation, and localization. 

With Docusaurus, we built our docs as markdowns and exported them as a static site. We created reusable custom components and now have complete control over how we build our documentation. The [MDX](https://mdxjs.com/) integration is also particularly useful, as it allows any JavaScript code to be embedded into the .md file. 

With a few lines of code, we could tweak our theme to suit our brand colors or customize any part of our documentation by [swizzling](https://docusaurus.io/docs/swizzling) the components we wanted. We also could use plugins to extend the functionality we got from Docusaurus. An example is the plugin for our search feature that allows customers to find relevant documentation.

![built-our-docs-2](//images.ctfassets.net/z7iqk1q8njt4/7umSHw0duZhot5KinxvX5g/1cf7082bd4060524f991dda6f714814b/built-our-docs-2.png)

I also built our custom API explorer myself, which enables developers to try out our API methods directly from our docs. I built it as an embedded React component placed in the MDX file. Because we host our documentation on [Vercel](https://vercel.com/), we could utilize Vercel Functions to proxy the API Explorer requests to the Courier API through our docs backend endpoint.

![built-our-docs-3](//images.ctfassets.net/z7iqk1q8njt4/5UGnlKtqc5VETHZdpcSUO6/270125cefaca0baf3b7d712a4120c059/built-our-docs-3.png)

With Docusaurus, we have been able to build our documentation quickly and easily. We can now make updates by simply cloning the repo on [GitHub](https://github.com/), branching off our main branch, implementing the changes, and creating a pull request (PR). Once someone has reviewed and approved the PR, it’s merged with the main branch, which deploys to Vercel and updates our site with the changes.

All we need to contribute to our documentation is a GitHub account and an integrated development environment (IDE). This helps us keep track of every maintenance task for our documentation.

## What’s next for our documentation?
There are a few more goals we have for our documentation. We have yet to utilize Docusaurus’s localization feature, so that’s in the works. We have also recently made our documentation [open-source](https://github.com/trycourier/docs) to welcome external contributors. This way, the user can take ownership of the updates they want and help themselves and others who would benefit from their contribution.

Until then, learn to use Courier via our [documentation and tutorials](https://www.courier.com/docs/guides/tutorials/how-to-design-a-notification-template/). We also [live stream](https://www.twitch.tv/trycourier) content that’ll help you get [started and continue with Courier](https://www.youtube.com/channel/UCuONBIOzl-hypZ5qqWKDeeg).


Find out how Courier used ReadMe and Docusaurus to build their documentation and what they learned in the process that might be useful to you.


Great documentation is crucial to engineering teams!

built-our-documentation-header

To cover our bases, we needed to improve and expand our documentation and this time, we wanted to make it scalable with Docusaurus.

built-our-documentation-thumbnail

How We Built Our Documentation On Docusaurus

Last fall, we published [a post](https://www.courier.com/blog/why-remote-work-is-not-here-to-stay/) on how despite the ongoing impact of Covid-19, Courier would remain committed to keeping our office in San Francisco and focusing our hiring efforts on local talent in the Bay Area. As the company has evolved, we’ve decided to shift our approach to a remote-first model. Although we had good reasons to choose not to go remote earlier, this eventual change in mindset led to several new initiatives during the hiring process and to maintain company culture in a remote-first environment. This blog post will highlight some of these initiatives and why we chose them.

## Why weren’t we already remote?
There were a few reasons we didn’t move to remote-first sooner. Firstly, we believed it would be easier and quicker to onboard new employees in-person vs. remote. When you’re a small team, every single hire changes the entire dynamic of the company so it’s really important to make sure they have a great understanding of the company’s culture, strategy, product, tools, and customers. People generally tend to be less hesitant to ask questions when they see people in-person than over Slack, especially if they’ve never met them before. When speed is critical, poor communication can become a bottleneck and we thought focusing on in-person hires would shorten the onboarding process. Secondly, we believed that certain kinds of collaboration were not feasible in a remote environment - especially in scenarios that call for creativity and quick decisions such as product design, marketing campaign construction, and deal strategy. Third, we also believed that maintaining a physical presence as an early-stage startup would actually serve as a differentiator since we saw many other similar startups shift to remote-only and we had a handful of people join the team citing our office and the in-person experience we offered as motivating factors. We believed there were many other similar candidates who specifically sought out an in-person experience after over a year of remote-only work and we would be well-positioned to compete for their talent.

We’ve since learned that, while these assumptions were not completely unfounded, we overestimated the negative impact of shifting to remote-first. We had also always intended to eventually hire outside of the Bay Area as the company grew, but after another year of learning about the benefits of remote vs. in-person work, we decided to rapidly accelerate our timeline and immediately shift to a remote-first approach. 

There were two primary factors that led to our decision. The first is that even though we were ostensibly an in-person company, after March 2020, we never mandated office attendance even after many of the in-person restrictions were no longer legally enforced. The result was that we had many employees who, while based in the Bay Area, rarely came in person and who had onboarded and operated 100% remote since the day they joined. We found that they were just as effective as employees who were coming in regularly and we had not sacrificed any operational velocity or our existing company culture. Second, we also found that even though there were candidates who did indeed appreciate our commitment to maintaining a physical presence, there were many more who wanted the flexibility afforded by remote work. By shifting to a remote-first approach, we could actually offer an attractive work environment to both of those types of candidates and, after experimenting with this approach for a few of our open roles, we saw a large increase in our inbound talent pipeline for those roles. We simply could not move fast enough on hiring if we focused only on Bay Area talent. So if we had nothing to lose and lots to gain, it seemed like shifting to remote-first was a pretty obvious decision.

## Compensation and leveling philosophy
Of course, shifting to remote-first isn’t as simple as making an announcement and writing a post - we had to consider the long-term impact this would have on the company and how best we could support the growing percentage of our team that would be permanently remote. Firstly, we had to decide how we would compensate remote employees. We’ll be writing a separate post detailing our compensation and leveling philosophy, but ultimately, we decided it made the most sense to pay everyone the same amount regardless of where they were based (within the U.S.) and to make compensation and leveling information completely transparent internally and in all external job postings. This would be the fairest approach for all team members and would minimize the associated administrative overhead while also making expectations clear to any prospective candidates. 

## Cultural and communication expectations
We also decided to make our cultural and communication expectations more explicit in the recruiting and onboarding process for new hires. Some examples of the kind of communication behavior we now explicitly outline for all employees include: preferring public Slack channels to DMs, encouraging asynchronous communication over synchronous, and sharing notes from in-person meetings with context in Slack. We also introduced a handful of new ongoing company activities to help remote employees get to know everyone on the team such as monthly virtual hangouts (escape rooms, games, etc.), quarterly in-person events where we bring the entire team in for some fun, and starting new employees in cohorts when possible instead of by themselves and encouraging them to come in-person for at least a few days in their first few weeks (travel expenses all covered by Courier). 

## Reviews for new hires
Lastly, in an effort to help us better identify how we as a company could support new employees when they first join, we are instituting a 30 day review process for all new hires when they hit 30 days from their start date. Instead of focusing exclusively on performance indicators as most review processes do, we are going to be emphasizing behavioral indicators of success at Courier via peer reviews. Some examples of indicators that we believe will be correlated with success are “proactively asking questions”, “offering feedback”, “taking ownership”, and “proactively suggesting improvements”. The goal of this process is to help reinforce the work philosophy at Courier for new hires (and reviewers - they’ll have to be on the lookout for these behaviors) and help us think about what we should be looking for in the hiring process to make sure there is a mutual great fit with all candidates. 

## The impact of this decision
Since we announced this change to the team a few months ago, we’ve seen a largely positive reaction. Ultimately, this change allowed existing team members more flexibility since they can now live anywhere in the U.S. without any changes to their compensation or they can keep coming into the office as they already were. We’ve also noticed a significant increase in our inbound talent pipeline across all roles from candidates who want a primarily remote experience. It’s worth noting that even among the non Bay Area hires we’ve made, they’ve all come and visited at least once already and our Head of Developer Relations, Nočnica, who is based in Portland, actually cited her experience having lunch with the team in the office during the interview process as a primary factor in her decision to join Courier. We’re excited to see that this has been received well by our existing team members and potential candidates alike and will be continuing to think of improvements we can make to build a world-class workplace at Courier. 

If you’re interested in learning more about opportunities at Courier, check out our open roles [here](https://jobs.lever.co/trycourier/).


Request a demo to see how Courier works to make product notifications delightful.

Want to learn more about Courier?

Several people sit on blue clouds away from each other with their office in a cloud at the back, but are working together remotely

now-remote-first-header

We wrote a blog post about why Courier would never be permanently remote. This post covers why we changed our minds and Courier is now a remote-first company.

Courier [Courier]

Build your first notification in minutes

Build your first notification in minutes

Product

Developers

Resources

Company