Wadawurrung Traditional Owners launch economic hub, providing vital business support and growth opportunities for local Aboriginal businesses.

New business hub empowers Wadawurrung artists | The Courier | Ballarat, VIC

The Best Courier Companies in the USA: 1. FedEx 2. UPS 3. Pace Couriers 4. DHL 5. ShipBob 6. Spee Dee Delivery Service 7. Lasership 8. USPS 9. Sky Postal

The 10 Best Courier Companies in the USA (2022)

Our team has compiled a list of the top 10 best courier companies in the United States of America (U.S.A.):- 1) FedEx, 2) USPS, 3) UPS, 4) Blue Dart, 5) DHL, 6) ShipBob, 7) Central Courier, 8) LaserShip, 9) Aramex, 10) SkyPostal.

Top 10 Best Courier Companies in USA (United States) [2024]

At Premier Courier Service in NYC, we recognize that our customers depend on Premier Courier Service to extend a level of same day nyc messenger service where NO is not an option. Deadline deliveries and special rushes are always welcome, and a Premier messenger in your office or in front of ...

Premier Courier Services: Best Courier & Messenger Service in NYC

Admiral Courier Services, Inc. serves the New York City metropolitan area, where it provides round-the-clock service for a range of industries and businesses. The company is highly experienced; it has been in business for more than 25 years, and it uses trucks, vans, and bicycles to reach its ...

12 Best New York City Courier Services | Expertise.com

This service is named Reliable Couriers for a reason, and I am very thankful to have found them. They knew how to help me arrange a complicated pickup and drop-off in a city that I’ve never been to! I gave them the details and the people to contact if they needed help, and they literally ...

New York City, NY - Same Day Delivery & Courier Service | Reliable ...

Our commitment is to beat any traditional courier company out there. How? You get unbeatable drivers availability (24/7) with up to a minute ETA for pickup and delivery times · Your driver is dispatched in minutes, not hours. You get access to a vast distributed network of professional drivers that is unattainable for any traditional courier...

San Mateo Local Delivery Price | Rapidus: 1-Hour & Same-Day Business ...

As one of the oldest and most well-respected courier services in New York City, our lightning quick messengers are legendary. Plus, our truck delivery and logistical divisions are ready with fast, effective and cost-efficient solutions to any challenge.

NYC Courier Service, Truck Delivery and Logistics - Breakaway Courier ...

Get List of Courier Companies in New York with key contacts emails like CEO, CFO, HR Head, Marketing Head for free.

List of Courier Companies in New Yorks

We also are a full service logistics company and provide warehousing for Final Mile Deliveries for any size retailer in the US or overseas. We have 30 years of experience in expedited shipping and do not try to force you into a “one size fits all” solution. You will see as you navigate through our site that we offer many options. Our couriers ...

Courier Service NYC | Fast,Reliable – Need it Now Courier

Courier

courier

Having a clear idea of how your users interact with your app — when they log in, which features they engage with, or which notifications they click on — can help you design a better experience and ultimately increase user engagement. But retracing your users’ steps across various integrations is a complex task. Customer data platforms (CDPs) like Segment seek to achieve it by aggregating event data from multiple sources in one centralized location. This helps businesses gain a clearer picture of their users, and use that insight to individualize the app experience. How an app communicates with its users is key. Whether you’re using web and mobile push notifications, an in-app inbox, automated email and SMS messages, or Slack notifications: all of that can have a huge impact on how the app experience is perceived by your users. That’s why it’s so vital to track notification usage data in your CDP. Today, we’re excited to announce that teams using Segment can now ingest notification usage data from , so that it can serve as a basis for new insights. Which communications were successfully delivered? Which ones were opened and read? On what channels? These types of events generated in Courier can now be used to create custom user journeys. Courier This step completes the integration of the two services: previously, . Now that the integration has come full circle, let’s have a look at how your organization can benefit from combining the two tools. Segment was available as a data destination in Courier , CEO & Founder, "Courier’s Segment integration really sealed the deal. You can simply get more understanding of the customer journey and the actions and the events that are being triggered along the usage of the product." Pierre-Camille Hamana Hospitable Marrying Courier and Segment In case you haven’t heard of us before, Courier is a notification platform that lets you develop, scale and manage multi-channel notifications for your application. Combining powerful API primitives with a no-code UI for designing and monitoring notification flows, Courier makes it far easier to build notification experiences that work in sync with your application UX than if you created a complex notification infrastructure from scratch. is a popular customer data platform (CDP) that lets you collect data generated by your users in various locations and assemble it in one place. This gives you a more complete picture of your users, allowing you to target them in a smarter and more personalized way. If your organization uses different tools to track and store user interactions, then you’re likely using a CDP-like Segment. Segment In Segment, your users’ interactions are stored as “events,” complete with metadata that you define in advance. Events can be associated with a user’s ID, or be stored anonymously, depending on permissions. You can then retrieve them for further data analysis, like aggregating and partitioning events according to different criteria, depending on the questions you’re trying to answer. For instance, you could be looking at general user engagement with a specific notification, announcing a new product feature. Or you could use your event data to understand how a specific group of people — for instance, 25- to 35-year-olds located in Southern Africa — engaged with your notification within a particular timespan; say, within 24 hours of sending the notification. Such information can now easily be obtained, thanks to the two-way integration of Courier and Segment. Sharing data between Courier and Segment benefits both the engineer looking to create a more organic notification experience for their users and the data analyst who wants insights into how users are interacting with a given product. The Courier Segment integration enables you to reap the full benefit of combining both tools. Courier as a destination for Segment events Many product teams already use Segment and Courier today. For the last two years, the in Segment has allowed companies like to create impactful multi-channel notification experiences. Event data tracked in Segment would flow into Courier, and trigger pre-configured notifications. Courier destination Hospitable For example, you could respond to a user’s actions — such as the purchase of a particular product or a password reset request — by sending out a particular notification via an in-app inbox message, a push notification, or an email. By combining Segment event data with Courier’s notification-sending abilities, teams can design a notification experience that feels personalized and tailored to the user’s product journey — with almost no engineering effort. Understand your users more fully through notification data However, when you send out a notification to your users, that in turn creates new event data. Did the user click on your notification within a certain time span? How many notifications were not delivered? What percentage of users unsubscribed? All that is extremely valuable information when trying to form a full picture of how your users engage with your product. By integrating , you can now make the most of that valuable data. Simply import notification events into Segment, where you can combine them with data from other websites and apps. Courier as a source of events in Segment Once connected, Courier can send two types of user data to Segment: message events and audience events. Message events Message events are related to the deliverability of your notifications, as well as how your users engage with them. Whether a message was sent, delivered, clicked, and opened: all of that can be observed via message events. By combining these events with other data, you can gain valuable insights. Let’s say, for example, that users in a certain region seem to engage less with messages that are sent at a specific time of day. You can now experiment with different sending times, and see whether that increases metrics such as the open rate. Or perhaps the notification title doesn’t work as well for certain audiences? You can tweak it and see if that improves user engagement. Audience events are Courier’s dynamically defined user groups, which are more flexible than static lists. For instance, you can define an audience that is located in the US. When a user from that audience travels abroad and their profile is updated, they will automatically be removed from the US audience based on their updated location. That will, for example, affect the times at which they receive a message — so you can make sure that nobody is woken up by an email trying to sell them a product, or similar disruptive behavior. Audiences Once your message and audience events are in Segment, you can aggregate and view them to gain insights, or route them to an analytics destination like Tableau or Looker. Thanks to the Segment integration, you’re now able to perform , and gain powerful insights about your users’ journey. Having a clearer understanding of how your users engage with your messages will help you create even more delightful notification experiences. analytics on your notification data Get started The Courier Segment integration is available now to all users. Read the to get started. For those already using Courier as a destination for Segment events, setting up Courier as a data source is simple. You can by wiring up your Segment write key. docs add Courier as a data source By making Courier available as a source in Segment, we’re getting one step closer to a full understanding of your users’ actions and motivations. Try it out today!

Smarter Customer Engagement Flows with Courier's New Segment Integration

Flujos de interacción con el cliente más inteligentes con la integración del nuevo segmento de Courier

Des flux d'engagement client plus intelligents avec la nouvelle intégration de segment de Courier

कूरियर के नए सेगमेंट इंटीग्रेशन के साथ स्मार्टर कस्टमर एंगेजमेंट फ्लो

Courier の新しいセグメント統合によるよりスマートな顧客エンゲージメント フロー

Fluxos de engajamento do cliente mais inteligentes com a integração do novo segmento da Courier

Luồng tương tác của khách hàng thông minh hơn với tích hợp phân đoạn mới của Courier

通过 Courier 的新细分市场整合实现更智能的客户参与流程

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 to send emails for this project . Courier 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: : type-safety and auto-completion are the best, right? Typescript : a production-ready framework to build a full-stack app, even for beginners. Next.js : 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. Prisma : enable us to easily build end-to-end type-safety between our Next.js client and server. Trpc Courier API: a great service/platform to handle our notifications, such as email, SMS, and much more. You can find the full for reference. source code here Goals Before building the features, let’s define our goals. Send invoice link to client’s email. Send a reminder a day before an invoice’s due date. Cancel an invoice due date reminder when the invoice is already paid. 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 for my email notifications. brand 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. 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 file in to keep all Courier-related code. Also, I will use which already abstracted all Courier API endpoints to functions. courier.ts src/lib/ courier node.js client library 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. 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 by clicking the preview tab. Then, it will show a prompt to name the event and set 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. test event data {} 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 will be populated with the previous that I created. data test event Backend I will copy the test to the file and copy the snippet to . AUTH_TOKEN .env src/lib/courier.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 function that will be responsible for sending an email. To send an email from the code, I use the function. sendInvoice courierClient.send() // 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 function. sendInvoice // 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 trpc endpoint that resides in . sendEmail 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 // 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 request. Let's break it down. POST Trpc way of defining by validating with Zod. Here I define all data that are needed for the function. request input from client sendInvoice .input(
 z.object({
 customerName: z.string(),
 invoiceNumber: z.string(),
 invoiceViewUrl: z.string(),
 emailTo: z.string(),
 invoiceId: z.string(),
 productName: z.string(),
 dueDate: z.date(),
 })
 ) Define a request handler (mutation). POST // 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 function which is a thin wrapper of useMutation`. trpc.useMutation() tanstack-query's Let’s add the mutation function. On successful response, I want to send a success toast on UI. //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. //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. //src/pages/invoices/[invoiceId]/index.tsx

<Button
 variant="primary"
 onClick={sendInvoiceEmail}
 isLoading={sendEmailMutation.isLoading}>
 Send to Email
</Button> Here’s the working UI. 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 First, let’s design the email template in Courier designer. As I already go through the process before, here is the final result. Before adding the function, define the types for the parameter and refactor the types. // 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 function to scheduleReminder src/lib/courier //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 after a successful attempt. Let's modify the trpc endpoint. scheduleReminder sendInvoice sendEmail // 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. 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 function that can cancel any automation workflow in . cancelAutomationWorkflow src/lib/courier.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 action with a matching . cancel cancelation_token Add cancelation_token to , I use the invoice's Id as a token. scheduleReminder // 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 when an invoice's status is updated to in the trpc endpoint. cancelAutomationWorkflow PAID updateStatus // 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. 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 type by default. I will also have all functions' return value in consistent with the below format. CourierHttpClientError src/lib/courier.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 block to all functions in . try-catch src/lib/courier.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 trpc endpoint. sendEmail // 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. 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 . I occasionally help other developers on in my free time. on my blog FrontendMentor Connect with me on . LinkedIn Quick Links 🔗 Courier Docs 🔗 Contribute to Invoys 🔗 Invoys Motivation Also published . here

Sending an Invoice and Adding a Payment Reminder in Next.js with Courier API

Enviar una factura y agregar un recordatorio de pago en Next.js con Courier API

Envoi d'une facture et ajout d'un rappel de paiement dans Next.js avec l'API Courier

कूरियर एपीआई के साथ नेक्स्ट.जेएस में चालान भेजना और भुगतान अनुस्मारक जोड़ना

Courier API を使用して Next.js に請求書を送信し、支払い通知を追加する

Enviando uma fatura e adicionando um lembrete de pagamento em Next.js com Courier API

Gửi hóa đơn và thêm lời nhắc thanh toán trong Next.js với Courier API

使用 Courier API 在 Next.js 中发送发票并添加付款提醒

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! 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 make using this model in our app very easy. Hugging Face Hugging Face We'll use the 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: Hugging Face We can fine-tune the GPT2 model by using our own text for which we'll need a good dataset of quotes. Or we can find an existing model which has been fine-tuned with some quotes. already 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 from transformers import AutoTokenizer, AutoModelWithLMHead, pipeline

tokenizer = AutoTokenizer.from_pretrained("nandinib1999/quote-generator") then constructing a model from the pre-trained model model = AutoModelWithLMHead.from_pretrained("nandinib1999/quote-generator") and finally, constructing the generator which we can use to generate the quote 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. Load the model every time we want to run the script to send the script. 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 __ __to build a quick serving API. Here's what that looks like Fast API # 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 $ 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 endpoint that will generate a quote for us. /generate 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 . 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. Courier Generate quote Given our API, we can now do the following to generate a quote 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 which provides a nice endpoint to return a random image matching a query. Opening in our browser returns a nice nature image. https://source.unsplash.com/random/800×800/?nature 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 - 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 How will the text be placed on the image? What about wrapping the text? What color should the text be so that it is visible on the background image? 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. # 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. 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. Creating the template in Courier 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 its API endpoint to keep things simple. With my and in hand, we can use the following piece of code to send our image AUTH_TOKEN TEMPLATE_ID 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 and the Template ID can be found in the settings. And that's it! Settings template design's 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 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. Prakhar Quick Links 🔗 Courier Docs 🔗 Hugging Face 🔗 Fast API 🔗 Unsplash API

Using Courier and GPT2 to Generate a Motivational Quote of the Day

Uso de Courier y GPT2 para generar una cita motivacional del día

Utiliser Courier et GPT2 pour générer une citation motivante du jour

दिन का एक प्रेरक उद्धरण उत्पन्न करने के लिए कूरियर और GPT2 का उपयोग करना

Courier と GPT2 を使用して、その日の動機付けの引用を生成する

Usando Courier e GPT2 para gerar uma citação motivacional do dia

Sử dụng Courier và GPT2 để tạo trích dẫn tạo động lực trong ngày

使用 Courier 和 GPT2 生成每日励志名言

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 , 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. 34% of employees prefer to be fully remote 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

Courier is Building a Healthy, Inclusive Work Culture to Attract Top Talent

Follow along with the video tutorial: https://youtu.be/6W2rIyUdmas?embedable=true We are launching our first hackathon next week, and giving away over $1K in prizes! Join us in building a cool project and winning any of the following prizes 🏆 Top submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive $1000 via Zelle or PayPal. Courier Hacks 1st Place: 2nd Place submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive the Apple AirPods Pro. Courier Hacks 2nd Place: Public favorite winner will receive a Keychron Keyboard. Public Favorite: Runners-up submissions will receive a Hydro Flask. Runners-Up: Additionally, everyone who submits a project successfully integrating the Courier API will receive a $20 Amazon gift card! Not sure where to start? In this tutorial, we will be building a Node.js app that sends multi-channel notifications in morse code. What’s going on? We are secret agents today, and our goal is to send encoded messages to our spy network. Some spies prefer reading emails, and others prefer reading texts, so we need to ensure that our app can accommodate all spy preferences. The first five secret agents to successfully complete this tutorial and this task will receive a gift from Courier. Note: In Chapter 1, we will first integrate the Gmail and Twilio APIs, which Courier will use to send emails and text messages. In Chapter 2, we will demonstrate how to send single messages and setup routing to send multi-channel notifications. In Chapter 3, we will integrate a translation API to convert our messages into Morse code. We are hosting our first hackathon next month, starting September 5th until September 30th. Register now to submit this project for a chance to win some cool prizes. Register for the Hackathon: https://courier-hacks.devpost.com/ Instructions Chapter 1: Authorize Courier to send messages using Gmail and Twilio APIs In this first Chapter, we will need to authorize our API to send the secret messages. Let’s get started by integrating the Gmail and Twilio APIs, enabling Courier to send emails and messages from a single API call. Log in to your Courier accountLog in to your Courier account and create a new secret workspace. Log in to your Courier account For onboarding, select the email channel and let Courier build with Node.js. Start with the Gmail API since it only takes seconds to set up. All we need to do to authorize is log in via Gmail. Now the API is ready to send messages. Copy the starter code, a basic API call using cURL, and paste it in a new terminal. It already has saved your API key and knows which email address you want to send to, and has a message already built in. Once you can see the dancing pigeon, you are ready to use Courier to send more notifications. Before we build out our application, we need to set up the Twilio provider to enable text messages. Head over to “Channels" in the left menu and search for Twilio. You will need an Account SID, Auth Token, and a Messaging Service SID to authorize Twilio. Open , login and open the Console, and find the first two tokens on that page. Save the Account SID and Auth Token in Courier. twilio.com Lastly, you need to locate the Messaging Service SID, which you create in the Messaging tab on the left menu. Checkout Twilio’s docs on , linked in the description. how to create a Messaging Service SID Once we have all three pieces of information, install the provider. Now your Courier account is authorized to send any email or SMS within one API call. Chapter 2: Send single and multi-channel notifications In this next Chapter, you will start sending messages. To send the secret messages, head to the . Here you can find everything related to sending messages. Send API documentation On the right, you will see some starter code and can select a language of your choice from cURL, Node.js, Ruby, Python, Go, or PHP. Selection Node.js to get started // 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'
  },
  body: JSON.stringify({
    "message": {
      "template": "NOTIFICATION_TEMPLATE"
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err)); This basic POST request can be edited to include the spies’ data such as how to contact them and the message you need to send. The “Notification Template” can be replaced with your own template. Add an email address in the email field on the left, which you will notice automatically appears in the code snippet on the right. // 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'
  },
  body: JSON.stringify({
    "message": {
      "template": "NOTIFICATION_TEMPLATE",
      "to": {
        "email": "courier.demos+secretmessage@gmail.com"
      }
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err)); Next, you need to add the actual message you are sending. These messages are pretty simple, so you can write them directly into the API call instead of creating a template. Write in a subject in the title object (this can be changed anytime). In the email body, write your message. // 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'
  },
  body: JSON.stringify({
    "message": {
      "to": {
        "email": "courier.demos+secretmessage@gmail.com"
      },
      "content": {
        "title": "new subject",
        "body": "message"
      }
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err)); As before, the data on the left automatically appears in the code snippet on the right. There is a content object that encompasses the title and body parameters. Now you just need to make sure that this API call has access to your Courier account, which links to the Gmail and Twilio APIs. Replace the Auth Token with the Courier API Key (stored in Courier account settings under API Keys)[ ]. https://www.courier.com/docs/guides/getting-started/nodejs/#getting-your-api-keys // 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 apikey'
  },
  body: JSON.stringify({
    "message": {
      "to": {
        "email": "courier.demos+secretmessage@gmail.com"
      },
      "content": {
        "title": "new subject",
        "body": "message"
      }
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err)); Send this code out from here to test that the API call works (click "Try it" above the code snippet). Go to your and click on the latest log for more information. You should be able to view how it is rendered for the user receiving the message. If there was an error, you should also be able to access an error code there. Courier logs Now you can integrate this code into our own Node.js application. Open VS Code and open a new project with a file called . index.js Past the code into the file. index.js Install the node-fetch npm package, enabling you to make API calls. Open a terminal and paste the command to install the package. $ npm install node-fetch --save Run the program in the terminal. $ node index.js Here, you may run into a node-fetch error, which is caused by the require statement on line 4. To fix this, install a different version of the package found on the node-fetch documentation: . https://www.npmjs.com/package/node-fetch#class-response npm install node-fetch@2 Now when you run this program, you should get a response from Courier that includes the in the VS Code console. This indicates that the API call was made successfully, and you can head over to the Courier datalog to determine if the message was also sent successfully. requestID Since you are a Secret Agent, you should probably protect the API key in case our code gets into the wrong hands. Create a new file called . .env Store the API Key as a variable in the .env file. APIKEY="fksdjfgjsdkfgndfsmn" Install the dotenv npm package, allowing you to access the variable in the file. index.js Once the package is installed, access the key by referring to it as . process.env.APIKEY Add to the top of the file. require('dotenv').config() index.js Run this program to confirm that it still works the same. At this point, you can send a single message to the spies via email. However, you know that some spies prefer to use text messages, so you will need to enable multi-channel notifications. Let’s head back to the Courier docs and scroll down to the object, which contains the and . Two types of methods are available - and . ‘All’ means that Courier will attempt to send the message to every channel listed. “Single” means that Courier will attempt to send it to the first channel that works. Let’s integrate this into our program. routing method channels all single Add the object anywhere within the object, at the same level as and . routing message to content Define the channels within the same object - you can choose SMS or email, in this case, since you already have an email address defined. routing "message": {
    "to": {
      "email": process.env.EMAIL
    },
    "content": {
      "title": "new subject",
      "body": "message"
    },
    "routing": {
      "method": "single",
      "channels": "email"
    },
} Convert the property into an array to define multiple channels and list both email and SMS. channels "channels": ["email", "sms"] You now have two different channels that this message can be sent to. methods would send this message to both email and SMS. method would try to send this to the first that works. Since you have the user’s email address but not their phone number, this program can only send it via email. All Single If the two channels were reversed, Courier would try to send an SMS, fail to do so, and then default to sending an email. "channels": ["sms", "email"] Add the user’s phone number to make the SMS channel work. Now this program should be able to send text messages via Twilio. "message": {
    "to": {
      "email": process.env.EMAIL,
      "phone_number": process.env.PHONENUMBER
    },
    "content": {
      "title": "new subject",
      "body": "message"
    },
    "routing": {
      "method": "single",
      "channels": ["sms", "email"]
    },
} Change the single method to and run the program again. all "message": {
    "to": {
      "email": process.env.EMAIL,
      "phone_number": process.env.PHONENUMBER
    },
    "content": {
      "title": "new subject",
      "body": "message"
    },
    "routing": {
      "method": "all",
      "channels": ["sms", "email"]
    },
} Courier can now send via Twilio and Gmail within the same API call. Chapter 3: Integrate a translation API to convert messages to Morse code NOTE: The Morse API has a rate limit, which may give you an error if you run it too many times within the hour. In this case, you will have to wait for some time before continuing. In this last Chapter, you will integrate the Fun Translations Morse API to encode the secret messages and send them over to the spies. You can search for documentation on the Morse API on the Fun Translations website.. Here you have access to all the information you need to make the call - you have an endpoint and an example demonstrating that the original message is a parameter for the endpoint. 🔗 Fun Translations: https://funtranslations.com/api/#morse 🔗 Fun Translations API: https://api.funtranslations.com/ Start by encasing the Courier API call in a function. Add a call to that function below the async function definition. Refactor to . options courier_options // Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');
require('dotenv').config()

async function send_secret_message() {

    const courier_options = {
        method: 'POST',
        headers: {
          Accept: 'application/json',
          'Content-Type': 'application/json',
          Authorization: 'Bearer ' + process.env.APIKEY
        },
        body: JSON.stringify({
          "message": {
            "to": {
              "email": process.env.EMAIL,
              "phone_number": process.env.PHONENUMBER
            },
            "content": {
              "title": "new subject",
              "body": "message"
            },
            "routing": {
              "method": "all",
              "channels": ["sms", "email"]
            },
          }
        })
      };

      fetch('https://api.courier.com/send', courier_options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));

}

send_secret_message() Before sending the message, you first need to make a call to the Morse API to translate the message. You can use node-fetch in the same way as you did for Courier to make this call. Copy the code within the async function to make the new API call. Paste the code above the Courier API call. Update the endpoint to the Morse API endpoint. Refactor to for the first call. options morse_options Remove the authorization token in the Morse API call since it does not require an API Key. Remove the object. body Add the message - “hey secret agent x this is your message” - as a parameter within the endpoint and replace all spaces in the message with its url-encode (%20). // Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');
require('dotenv').config()

async function send_secret_message() {

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

      const original_message = "hey%20secret%20agent%20x%20this%20is%20your%20message"
      const morse_endpoint = "https://api.funtranslations.com/translate/morse.json?text="+original_message

      fetch(morse_endpoint, morse_options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));

    const courier_options = {
        method: 'POST',
        headers: {
          Accept: 'application/json',
          'Content-Type': 'application/json',
          Authorization: 'Bearer ' + process.env.APIKEY
        },
        body: JSON.stringify({
          "message": {
            "to": {
              "email": process.env.EMAIL,
              "phone_number": process.env.PHONENUMBER
            },
            "content": {
              "title": "new subject",
              "body": "message"
            },
            "routing": {
              "method": "all",
              "channels": ["sms", "email"]
            },
          }
        })
      };

      fetch('https://api.courier.com/send', courier_options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));

}

send_secret_message() Comment out the Courier API call, since you only need to test the code you just added. When you run this program, we may receive an error that states that there is an error parsing the JSON. This issue is caused by an error in the documentation, which here states that it should be a request. However, on a separate API documentation, it is written as a request. Update the call type to and you should see the translated message within the response. POST GET GET, ObviouslyClearly, you don’t want to send all of this information to the spies, y. You only need the secret message. Isolate the message by logging . response.contents.translated fetch(morse_endpoint, morse_options)
    .then(response => response.json())
    .then(response => console.log(response.contents.translated))
    .catch(err => console.error(err)); You need to be able to access the translation from this API call in the body of the Courier API call. Create a variable called , which will hold the entire response from this call. morse_response Convert the JSON object into a JavaScript object so that you can read it within your code. Get the translated message out of that object and save it in a new variable called . message Log this variable to confirm that it works. const morse_response = await fetch(morse_endpoint, morse_options)
    // .then(response => response.json())
    // .then(response => console.log(response.contents.translated))
    // .catch(err => console.error(err));
const translation = await morse_response.json();
const message = translation.contents.translated
console.log(message) Replace the message within the body of the Courier API call with the encoded message you just saved in the variable. message "message": {
    "to": {
      "email": process.env.EMAIL,
      "phone_number": process.env.PHONENUMBER
    },
    "content": {
      "title": "new secret message",
      "body": message
    },
    "routing": {
      "method": "all",
      "channels": ["sms", "email"]
    },
} The Courier datalog should show that the messages were successfully encoded and sent via both SMS and email. Here’s what the email looks like: Conclusion Our spies are now ready to receive their secret encoded messages. Try changing the body of the content to your own secret message and send it over to ,and we will send a gift to the first five Secret Agents who complete this task! Don’t forget to submit your project to our for a chance to win over $1000 in cash and prizes!XYZ. courier.demos+secretmessage@gmail.com Hackathon Quick Links 🔗 GitHub Repository: https://github.com/shreythecray/secret-messages 🔗 Video tutorial: https://www.youtu.be/6W2rIyUdmas Log in to your Courier accountLog in to your Courier account 🔗 Courier: https://app.courier.com/signup?utm_campaign=Developer Relations&utm_source=secret-message app.courier.com app.courier.com 🔗 Register for the Hackathon: https://courier-hacks.devpost.com/ 🔗 Courier's Get Started with Node.js: https://www.courier.com/docs/guides/getting-started/nodejs/ 🔗 Courier Send API Docs: https://www.courier.com/docs/reference/send/message/ 🔗 Twilio Messaging Service SID Docs: https://support.twilio.com/hc/en-us/articles/223181308-Getting-started-with-Messaging-Services 🔗 Node-fetch: https://www.npmjs.com/package/node-fetch 🔗 Dotenv: https://www.npmjs.com/package/dotenv 🔗 Fun Translations: https://funtranslations.com/api/#morse 🔗 Fun Translations API: https://api.funtranslations.com/ Also published . here

Sending Secret Messages with the Courier API and Node.js

Envío de mensajes secretos con Courier API y Node.js

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. The issue One recurring issue that has come up with our developers is getting rate limited, i.e 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. 429 errors The fix There’s no workaround here. Gmail's API has 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. limitations Our recommendation is to check out 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. our full list 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. 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 . 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. integration documentation 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 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. Pagerduty 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 certainly makes it look good, and with the additional to match the look of your app and brand, how can one resist. And for our developers using non-react builds, we have for you. demo app customization options embedded integration 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 in your application. CourierProvider component 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. The fix Before we dive into the answer, let’s take a look at a sample send request in this case. 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: 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 for CourierProvider, Toast, and Inbox. packages 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 and , 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 now! docs articles demo request

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 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 to provide better communication between guests and hosts and to help retain users. Another line of important communication, however, exists between healthcare providers and patients, or with other providers. Hospitable LaunchDarkly 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 . If you’re looking for HIPAA-compliant notification infrastructure for your own organization, . series of articles check out Courier here

Courier's Journey to Becoming HIPAA-Compliant

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. - Sangen Zeb, GV “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." Courier’s vision is to be a single source of truth for 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! https://www.youtube.com/watch?v=tPB2wFI7u0I 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. - Eric Koslow, CEO, Lattice “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!” 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 an 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 the 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: // 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"
      }
    }
  ]
} Visit this page to learn more about this new mobile functionality and request a demo and check out 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 to learn more about Courier’s goals for mobile notifications! here If you are interested in helping to build the future of notification technology starting with mobile channels, we are ! hiring

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

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 , 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. LaunchDarkly , 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. Officevibe For , 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. Yoga International “Meetings Reminder” Let's build a meeting 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: Log into and navigate to the Courier Notifications Designer Design an email reminder that will  be sent 10 minutes before the meeting with the Gmail provider (or any email provider of your choice) Access the template ID in the settings of that notification and save it for future reference Design an SMS reminder that will be sent two hours after the meeting with the Twilio provider (or any email provider of your choice) 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) Within your Node.js app, install node-fetch npm install node-fetch Navigate to the and copy the starter code Automations API Reference Add an object with an array of objects called automations steps "automation": {
      "steps": [
        {
          "action": "send",
          "template": "template_id",
        }
      ]
    }, Automations API Reference Automations Docs 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. "automation": {
    "steps": [
      {
        "action": "send",
        "template": "template_id_1"
      },
      {
        "action": "delay",
        "duration": "130 minutes"
      },
      {
        "action": "send",
        "template": "template_id_2"
      }
    ]
  }, Update with the notification template from Step 3 of “Design the Message” and update with the notification template from Step 5 of “Design the Message” template_id_1 template_id_2 Update the and attributes with your preferred and IDs brand recipient brand recipient If your steps reference any Notification Templates, update the ID attribute template Run your code to trigger the Automation // 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)); Check the for delivery status and error messages Datalog How To Create An Automation Using the Studio This example demonstrates integrating an API V2 notification send call (Step 5 of "Design the Message"). Navigate to the page Automations Create an Automation Template from scratch Add a send step and select the “10-minute reminder” for the Notification Add a delay step and update the length to 130 minutes 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 {
      "action": "send",
      "message": {
        "to": {
      		"email": "example@email.com"
    	},
    	"content": {
    		"title": "Meeting Notes",
    		"body": "Link to meeting notes: ..."
    	}
      }
    } This step can be done within the designer by following Step 3 Select a trigger for the Automation (if no trigger is selected, the Automation can be triggered manually with a curl command) Publish changes to save your Automation Create a Test Event to test your Automation {
  "data": {},
  "profile": {
  	"email": "example@email.com",
	“name”: “Your Name”
  }
} 9. Invoke your Automation in the Designer or copy the starter code and run it in a terminal Getting Started to get started with Automation. Courier’s Free Tier includes Automations and up to 10,000 notifications per month. Sign up for a free Courier account Originally published here.

Application Logic for Notifications with Courier Automations

Lógica de aplicación para notificaciones con automatizaciones de mensajería

Last fall, we published 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. a post 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 Also Published here

Stories, News & Mentions about COURIER

Courier’s Stories on HackerNoon

Courier's News & Mentions