Forem: Colin White

The developer's guide to Slack's Markdown formatting

Colin White — Tue, 31 Oct 2023 18:06:17 +0000

Slack mrkdwn is Slack’s version of the Markdown language tailored for their platform. It allows developers to craft visually appealing and structured messages as well as emphasize critical information and add flair to their Slack messages.

In this guide, we’ll explore the nuances of mrkdwn, from its basic formatting capabilities to advanced features, coupled with practical examples to get you started and build the right Slack notifications for your application.

mrkdwn isn’t Markdown

At first glance, Slack’s mrkdwn and the popular Markdown syntax appear remarkably similar.

Both Slack’s mrkdwn and John Gruber’s Markdown syntax offer a way to richly format text using simple, plaintext notations. However, the design and capabilities of each of the languages is different due to their different purposes.

Markdown was designed as a lightweight markup language to convert plaintext into structurally valid HTML. It allows writers to easily ‘markup’ their text to convert it cleanly into HTML. Most developers will be used to Markdown in Github. You can use Markdown in both the Readme of a repo and individual commit messages. Markdown is also a core component of the Notion platform.

Slack’s mrkdwn is a custom formatting syntax tailored specifically for the Slack platform. Its sole goal is to make it easier to write rich, visually appealing text within Slack and take advantage of the core features of the platform such as @-mentions and channels.

The different purpose leads to core differences in the syntax. Most obviously, Markdown supports multiple header levels using #. For instance, ### Header 3 would represent a <h3> tag in HTML. mrkdwn doesn’t support multiple header levels in the same way. When would you use a header in a Slack message? It’s more streamlined for shorter messages.

The same goes for tables or syntax highlighting. These are core for a full document, but less important in Slack messages. Conversely, mrkdwn has special link formats, like <@U12345678> for user mentions or <!channel> to notify all members of a channel. Markdown doesn’t have a native equivalent for these functionalities given how platform-specific they are.

There are also some design choices within mrkdwn that are different from Markdown, such as the use of underscores for italics rather than a single asterisk, or angle brackets for links instead of square brackets.

Basic formatting: the foundations of mrkdwn

The core elements of mrkdwn help you convey your messages with clarity, emphasize key points, and make your text easy to scan and understand.

Three elements are commonly used with regular text:

Wrapping your text with asterisks (*) characters bolds the text to emphasize a word or phrase.
Wrapping your text with underscores (_) characters italicizes the text to emphasize subtly or indicate titles of works.
Wrapping your text with tildes (~) characters strikes through the text to indicate corrections or highlight something that’s no longer relevant.

Then we have two ways to add code to Slack messages. This could be particularly useful if you are building alerts for an application monitoring platform and need to show code that has failed.

Inline code is good for highlighting code, commands, or special terminology. For this, you wrap your text with backticks (`).

Multiline code blocks are ideal for sharing longer code snippets or preformatted text. To do this, you wrap your text with three backticks (`). To add a new line, you have to use \n.

Throughout, we are using the Block Kit to show how you build mrkdwn to use with the Slack API. Block Kit enables developers to build interactive and visually appealing messages in Slack. By incorporating mrkdwn within these blocks, you can achieve a fine balance between structure and textual presentation, ensuring your messages are not only interactive but also clear and captivating.

If you are writing these into your code for a notification app, here’s how they would look:

{
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "This is *bold* \n This is _italic_ \n This is ~strikethrough~ \n This is `code` \n ```This is a code block\nAnd it's multi-line```"
      }
    }
  ]
}

This message will read in Slack as:

The primary goal of this formatting is to enhance comprehension and draw attention to essential information. Overuse might make messages harder to read. So, while it’s tempting to jazz up every message with formatting, always prioritize clarity.

You can find all the special formatting for mrkdwn in the Slack mrkdwn formatting docs.

Links and mentions: engaging directly with users and content

A foundational element of Slack is that you can use notifications to directly engage individuals and teams through mentions and direct those users to specific channels, applications, or sites through links.

We can split these into two types: internal Slack links and mentions and external links to sites and emails.

Internally, mrkdwn uses the @ symbol to mention a specific user (such as @colin) or user group, such as @here, @everyone, or @channel. As with when you are working directly in Slack, etiquette is important here. Don’t @everyone unless you really need everyone.

Internal to Slack you can also highlight and direct users to other channels, using the hash symbol (#).

To link away from Slack, you use hyperlinks. The format for these in mrkdwn is <URL|Displayed Text>. So <https://knock.app|Knock> will render as a clickable link titled “Knock” leading to https://knock.app.

You can use this syntax to link to an email address as well, you just prepend the email address with the mailto protocol. So <mailto:hello@knock.app|hello@knock.app> will render as a clickable “hello@knock.app” link that opens a user’s default email client with hello@knock.app as the recipient.

Here are code examples of these:

{
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "This is a link to the <https://knock.app|Knock website> \n This is a mention of user @andrew \n This is an @channel mention \n This is a link to the #random channel \n This is an email link <mailto:hello@knock.app|hello@knock.app>"
      }
    }
  ]
}

This will show in Slack as:

When leveraging special links and mentions, always remember to consider the context and the intended audience. While mentions are a powerful way to get someone’s attention, they can be disruptive if overused.

Likewise, linking to channels or external sites should be done judiciously to ensure the message remains clear and focused.

Lists and blockquotes: structuring your message

Structuring messages lets you convey multiple points or highlight a specific piece of information. In mrkdwn, you can use lists and blockquotes to make your message more digestible.

There is no particular syntax for lists within mrkdwn, at least when sending messages via the API. Instead, you can use whichever symbol you want to specify an unordered list

{
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "- Item 1 \n - Item 2 \n - Item 3 \n - Item 4"
      }
    }
  ]
}

This renders to:

Ordered lists are just numbers or letters as the symbol. For instance:

{
"blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "1. Item 1 \n 2. Item 2 \n 3. Item 3 \n 4. Item 4"
      }
    }
  ]
}

This becomes:

To add blockquotes to highlight or emphasize a particular section, like a quotation or important note, you start a line with > followed by a space.

{
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "> This is a blockquote. It can span multiple lines and is often used to highlight specific pieces of information or quotations."
      }
    }
  ]
}

This renders as:

While lists and blockquotes are excellent tools for enhancing readability, they should be used thoughtfully. Too many lists can confuse readers, and excessive blockquoting might dilute the emphasis you’re trying to create.

Special formatting: elevating your Slack messages

There are a few other options with mrkdwn that you might need to use.

First, displaying dates in a consistent, readable manner with date formatting. Here, you use the timestamp in UNIX format with the syntax <!date^timestamp^{date_format}|{fallback_text}>, like this:

{
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "Today is: \n\n <!date^1697250654^{date_short}|Oct 13, 2023> \n <!date^1697250654^{date_short_pretty}|Oct 13, 2023> \n <!date^1697250654^{date_long}|Oct 13, 2023> \n <!date^1697250654^{date_long_pretty}|Oct 13, 2023> \n <!date^1697250654^{date_num}|Oct 13, 2023> \n <!date^1697250654^{date}|Oct 13, 2023>"
      }
    }
  ]
}

This renders as:

Tip: In JavaScript or TypeScript, use const unixTimestamp = Math.floor(Date.now() / 1000) to get the current date in UNIX format.

You can also combine some of the mrkdwn above. For example, to bold a link, you can use:

{
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "Here is a *bolded* link to <https://knock.app|*Knock*>"
      }
    }
  ]
}

Which will render a bolded link:

And, last but definitely not least, you have emojis:

{
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": ":earth_americas: :rocket: :star: :alien: :moon: :sun_with_face: :zap: :fire: :cloud: :umbrella: :rainbow: :cat: :dog: :mouse: :elephant: :tiger: :rooster: :snake:"
      }
    }
  ]
}

This gives us:

Remember, you can never have enough emojis.

Putting it all together: A mrkdwn alert

Let’s put all this together into an alert that an application monitoring platform might send through Slack. Some elements we might use are:

Notifying a specific individual or team. The application might get this information from a database of SREs or on-call individuals. Here we will use @-mentions.
A concise description of the alert. Here we will use basic formatting to highlight the issue.
Links to dashboards and pertinent information. So the team can go deeper into the issue
A list of steps to be taken. These can be predefined and added to the Block Kit
Date and time information. Then anyone seeing the alert will know when the alert happened.
Emojis. This can add visual appeal to the alert and draw attention to it.

Altogether, the mrkdwn for this alert would be:

{
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "@colin \n @sres \n\n *<!date^1697250654^{date_num}|Oct 13, 2023>* \n\n *[APM ALERT]: Elevated Error Rates Detected!* :red_circle: \n - Service: `User Authentication API` \n - Environment: `Production` \n\n :chart_with_upwards_trend: Metrics \n\n *Error Rate*: _15%_ (Threshold: _5%_) \n *Response Time*: _900ms_ (Average: _200ms_) \n *Throughput*: _1200 rpm_ (Requests Per Minute) \n :world_map: Geographical Impact: _US East, Europe Central_ \n  \n :sos: Related Incidents: \n <https://example.com|Database Latency Spike> \n <https://example.com|Redis Connection Failures> \n  \n :link: *Dashboard Link*: <https://example.com|APM Dashboard> \n  \n :speech_balloon: Recommended Actions: \n 1. Verify backend database health and connection. \n 2. Check Redis server and related metrics. \n 3. Assess recent deployments for potential issues."
      }
    }
  ]
}

This code looks complicated, but most of this information will be added dynamically from the APM. This creates a well-formatted, clear message for the team:

Use mrkdwn for clear communication

Slack’s mrkdwn is a powerful tool. Using mrkdwn enhances the readability and emphasis of critical pieces of information. The above example alert shows this, highlighting the crucial data for a team and making sure they can act on that information quickly.

Integrating mrkdwn into your Slack notifications not only beautifies the message but, more importantly, makes it exponentially more user-friendly. When time is of the essence, and clarity is paramount, leveraging the full potential of mrkdwn ensures that your alerts are not just noticed but acted upon effectively.

At Knock, we’ve taken mrkdwn further by integrating it into our templating engine and enhancing it with liquid tags for templating and an easy-to-use JSON editor. This allows you to design your Slack notifications exactly how you want them.

Check out some Slack notification examples for inspiration and sign up here to get started for free.

The top real-time notification services for building in-app notifications

Colin White — Tue, 24 Oct 2023 20:11:29 +0000

Real-time, in-app notifications in a product allow you to instantly engage users with relevant content, enhancing user experience and user retention. These notifications foster immediate action and feedback, ensuring users stay informed and connected to the application's latest updates and activities.

But building in-app notifications from scratch is challenging. First, you have to manage the infrastructure for WebSockets and Publish/Subscribe messaging patterns to power the real-time behavior. Second, your product needs logic to deal with user preferences, user presence detection, storage, and logging. Finally, you need to build out the frontend UI features and underlying APIs to display the notifications.

Using a SaaS service to offload some or all of this complexity allows you to concentrate on your own product while still giving the benefit of in-app notifications to your customers.

Here, we will evaluate 4 providers to power the real-time infrastructure for your in-app notifications.

The key features of real-time services for in-app notifications

What should you be looking for in a real-time service for in-app notifications?

Pricing: The cost-effectiveness of in-app notifications can significantly influence an app's overall budget and profitability. Transparent, scalable pricing ensures you can anticipate costs, allocate resources, and adjust any strategy based on budget.
Scalability: In-app notifications should adapt as user bases grow or shrink. A scalable notification system can handle spikes in traffic and vast volumes of concurrent users, ensuring every individual receives timely and consistent alerts without overburdening infrastructure.
Reliability: A reliable in-app notification system guarantees that users receive messages without delays. This reliability is vital for maintaining trust, especially in applications where timely alerts can impact user decisions or safety.
Framework: The chosen framework should support your desired communication mechanism, be it pub/sub for broadcasting messages to various subscribers, WebSockets for real-time bidirectional communication, or polling where the client periodically requests updates.
Features: Essential features to consider include presence (indicating who is online), low latency (ensuring rapid message delivery), the ability to query the state (understanding the current status of a user or system), and encryption (securing the content of the messages for privacy and protection).
Developer experience: An intuitive and well-documented platform streamlines the integration and maintenance process for developers. A positive developer experience translates to quicker implementation, fewer bugs, and more time spent refining and enhancing the core features of the application.

Let's look at a few services and how they align with these key features.

Pusher

Pusher Channels is a real-time notifications service that empowers developers to swiftly integrate real-time functionality, like live notifications and chat, into web and mobile apps using WebSockets. Pusher is known for reliability and scalability and is used by Buffer, GitHub, and Datadog.

Features

Managed WebSocket connections with fallback
Support for Publish/Subscribe framework
Presence detection
The ability to query the API to find out channel and state information
Interactivity through webhooks
End-to-end encryption

Pros

Scalability. Pusher easily handles surges in traffic, ensuring consistent real-time communication for applications ranging from startups to large enterprises.
Versatility. With SDKs for various languages and platforms, Pusher seamlessly integrates with numerous tech stacks, simplifying real-time feature implementation.
Reliable WebSocket fallback. Pusher's automatic fallback mechanisms guarantee continuous connectivity, even when WebSockets are unsupported or unstable.

Cons

Location. You are locked into a specific data center location when you sign up for Pusher and “it's not possible to change it afterwards.” This means that notification latency will slow further from the data center location.
Pricing complexity. With eight tiers and pricing changing with messages, connections, and support, it is not clear how you'll have to pay. You also have to pay separately for Pusher Beams, their Push notification service.

Pricing

Pusher has eight pricing tiers ranging from free on the “Sandbox” tier, where you get 200k messages per day and 100 concurrent connections, standard support and no monitoring, to $1,199/month on the “Growth Plus” tier for 90 million messages per day and 30,000 concurrent connections with premium support and monitoring. After that, you can contact the team for enterprise-level pricing.

PubNub

PubNub is a real-time communication platform based on HTTP long-polling instead of WebSockets. It provides scalable infrastructure to send and receive messages at low latency, and supports presence, compression, and storage. Customers include Niantic, Kustomer, and Autodesk.

Features

Uses the Publish/Subscribe framework to send high volumes of messages
Low latency messaging
GZip message compression
Message persistence for history through their storage API
Presence detection

Pros

Broad integration options. PubNub offers SDKs for numerous platforms and languages, making integration effortless across various development environments.
Robust feature set. Beyond just messaging, PubNub provides presence detection, storage, and playback, catering to diverse real-time app requirements.
High scalability. Built for large-scale applications, PubNub can handle millions of concurrent connections without compromising performance.

Cons

Pricing concerns. As message volumes or connections increase, costs can escalate due to usage-based pricing, making budgeting unpredictable for high-traffic applications.
Lack of WebSockets: PubNub uses the Publish/Subscribe model across HTTP rather than WebSockets. WebSockets have better scalability, better error handling, and lower latencies.

Pricing

PubNub has a free tier giving users up to 200 MAUs or 1M total transactions per month. They are clear that this is for testing purposes only and should not be used for production. For production-level applications, they have a $49/month tier that allows up to 1000 MAUs and 3000 transactions per MAU. Usage-based billing is used beyond those limits.

Ably

Ably is a robust real-time data delivery platform based on WebSockets with features like message ordering, presence, and connection recovery. Customers include Toyota, HubSpot, and Verizon.

Features

Low latencies of ~65ms for notification delivery
Queryable state API to find popular channels and user presence
Reduced bandwidth with delta compression
Also supports MQTT and server-side events as well as WebSockets

Pros

Connection State Recovery: Ensures interrupted users can resume their session without missing data.
Data Consistency: Guaranteed message ordering and delivery ensure that all users receive updates in the correct sequence.
Edge network. Ably uses 15 data centers around the globe and persists data across each to lower latencies.

Cons

Pricing Model: With a pay-as-you-go model, costs can escalate quickly with little control if you add more users and channels.

Pricing

Ably pricing has a free tier offering 6M monthly messages across 200 concurrent channels and 200 concurrent connections. They then move to a pay-as-you-go model which charges $2.50 per million messages, $15.00 per thousand concurrent channels, and $15.00 per thousand concurrent connections.

Socket.io

Socket.io is an open-source JavaScript library that facilitates real-time web communication. It simplifies bidirectional data transfer between web clients and servers. By abstracting WebSockets with fallbacks, it ensures consistent performance across devices and browsers, making real-time chats, notifications, and dynamic content more accessible for developers.

Features

Automatic reconnection
Middleware to filter and act on incoming packets
Built-in support for binary data.
Multiplexing through multiple namespaces

Pros

Ease of use: Socket.io offers a simple API, enabling developers to quickly integrate real-time functionalities without deep expertise in WebSockets.
Cross-platform: It provides client-side libraries for multiple platforms, ensuring broad compatibility across devices and browsers.
Fallback mechanisms: If WebSockets aren't available, Socket.io automatically falls back to other methods, ensuring consistent connectivity.

Cons

Scalability concerns: For very large-scale applications, Socket.io might face challenges, requiring additional configurations or optimizations.
Self-hosting: As Socket.io is only a library, you have to set up the infrastructure yourself.

Pricing

N/A. Socket.io is an open-source library that allows you to build real-time communication more easily.

Choosing the right solution

The above options are great choices for providing the backend infrastructure for real-time notifications. But if you want to use these real-time services as the foundation for in-app notifications, then you’ll have to think about what needs to be built around them. These options don’t feature:

UI components. While these services provide the backend infrastructure for notifications, they don't typically offer ready-to-use frontend components, meaning you'd need to design and implement the visual aspects of your notifications separately.
Templated messaging. You may need to build or integrate a system that allows for templated messages, letting you send consistent yet customizable notifications based on predefined templates.
Read receipts. Knowing if and when a user has seen a message can be vital for engagement and user experience. These platforms might not offer out-of-the-box solutions for read receipts, necessitating additional development.
Interactivity. These services deliver messages, but enabling interactive elements (e.g., buttons or links within notifications) would require additional development and design efforts.
User preferences. Tailoring notifications to user preferences, such as frequency, type, or topic, is crucial for a positive user experience. Incorporating such customization would need a separate mechanism or system.

Each of these will have to be built out for a complete in-app notification system.

Introducing notification infrastructure

Knock is a developer tool for building cross-channel notification systems. You can use it to add in-app notifications to your app with pre-built components to get you started quickly, but the power comes from integrating in-app and out-of-app channels such as email, push, SMS, and Slack. You can build workflows for these notifications so the right messages are sent via the right channels to the right users at the right time. We built Knock to be the best option for teams needing to implement any type of notification in their application.

Knock also takes care of all of your retry and delivery logic, as well as batching (collapsing multiple notifications about a single topic into one), managing per-user notification preferences, and providing unparalleled visibility into the notifications your product is sending.

Knock is an all-in-one notification platform that allows developers to build stateful, in-app notification experiences like floating feeds, inboxes, toasts and banners. Customers include Vercel, Amplitude, and Darwin Homes.

Features

Pre-built components to power in-app notifications that can be customized to match your brand
No infrastructure setup, no APIs to build
Workflow builder to determine how to alert users
Visual template builder to create and update notification templates
Preferences API to let users take control of their notifications
Strong support with responses in hours

If you'd like to try it out, you can sign up for a free account and get started by checking out our in-app feed docs. 👋

The 7 best transactional email services for developers in 2023

Colin White — Thu, 19 Oct 2023 14:54:57 +0000

If your application needs to send transactional emails, you'll need a transactional email provider to deliver those emails on your behalf. In this article, we evaluate our favorite seven transactional email service providers you can use as a developer in 2023.

Let's get to it.

The 7 best transactional email APIs for developers

SendGrid. An industry-leading email API with good deliverability and a comprehensive suite of analytics.
Postmark. Fantastic deliverability, a well-designed API, and a cost-effective solution for ensuring that your transactional messages get to your customers.
AWS SES. A highly reliable and scalable option for those who are already within the AWS ecosystem.
Mailgun. A developer-focused, scalable, and reliable email sending service.
Resend. Great for developers looking to build and send transactional emails with React or Next.
MailChimp Transactional (formerly Mandrill). Sold as a paid Mailchimp add-on. If you're already a user of Mailchimp to send marketing announcements, this is a good option.
Sparkpost. Good deliverability and a robust set of analytics tools make this a solid choice.

Why you should trust us

We're Knock and we're a developer tool for building production-grade, cross-channel notification systems.

We've built integrations with 20+ different notification providers, spent hundreds of hours working with (and discovering the intricacies of) their APIs, and seen up-close how they perform at scale across a wide range of use cases. Today Knock powers production notifications for Vercel, Teikametrics, and SafetyCulture.

What makes a great transactional email service?

Pricing and value. Cost matters. You want to ensure there's a free tier you can use to "kick the tires" of the service, and understand how the pricing scales as you start sending larger volumes of emails.
Deliverability. You're using a transactional email service so you don't have to think about deliverability. It's paramount that the transactional email service you use has high deliverability and gets emails to your customer's inbox in a timely fashion.
Ease of use. Integrating the service into your product should not be a burden, there should be simple instructions and a sane, easy-to-understand set up process to send your first email with the service.
Documentation and SDKs. As developer-focused services, these providers must have well-designed API and SDKs available in most major languages. Great documentation is also essential, helping you get the support and guidance you need if you get stuck during setup.
Analytics. Emails generate "exhaust data" for engagement data such as opens and clicks, as well as deliverability data. The service should easily give access to this data, and ideally, make it accessible via a dashboard.

We take an in-depth look at seven transactional email services using the above criteria as a guide to determine how the services stack up against each other. We've created an account on each service, set up a domain, and triggered emails to be sent to see how each service really performs.

As an aside, we used Knock here as a way to quickly integrate the transactional email service, build an email template, and send a test email through each service, without needing to write service-specific integration code. Knock can also take care of managing our email templates, giving us cross-provider analytics, and sending cross-channel notifications to other in-app and out-of-app channels like push, SMS, and Slack.

SendGrid

SendGrid is a widely-used email service from Twilio used by internet giants such as Uber, Booking.com, and Yelp to send and deliver their transactional emails. SendGrid is an excellent option for teams that want to get started quickly and have an email service that will scale with them over time.

SendGrid features

Comes with outbound (sending) and inbound (receiving) APIs.
Supports attachments via easy-to-use, base64 encoded content.
DKIM, DMARC and SPF supported.
Support for dedicated IP addresses.
Email address validation API. Note: this is billed separately from email sends.
Template management, including a visual template editor and a streamlined version control and approval process.

Pros

Great documentation and SDK support. SendGrid's documentation is easy to navigate, and the quick start guides make it easy to get integrated quickly. There's also SDKs available for most major languages.
Rich analytics tools. SendGrid has a full suite of tools for monitoring and reporting on email insights. They also offer programmatic access to this data via their API.
A focus on deliverability and scale. SendGrid has a number of tools to help with deliverability and makes this a core focus of their product, which includes their recent investment into A.I. powered intelligent delivery.

Cons

Email sending history is a paid add-on. SendGrid offers an extended email activity history add-on that grants access to 30 days of sending history, as well as API access.

SendGrid pricing

SendGrid offers 4 tiers of pricing: Free, Essentials, Pro, and Premier. The free plan offers 100 emails/day, while the Essentials plan starts at $19.95/month and includes 50,0000 emails each month with overages charged on top. Dedicated IP addresses email validations are available in the Pro plan and above. Volume based discounts are available on the Premier plan.

Postmark

Postmark is a transactional email service from ActiveCampaign that prides itself on its inbox deliverability. Compared to some of the offerings in this post, Postmark has a smaller set of customers but is still trusted to power emails for 1Password, Paddle, and Webflow. If you're looking for a no-nonsense service that focuses on deliverability, Postmark is an excellent choice.

Postmark features

Comes with outbound (sending) and inbound (receiving) APIs.
Supports attachments via easy-to-use, base64 encoded content.
DKIM, DMARC and SPF supported.
Support for dedicated IP addresses.
45-day message and log retention on all plans.
Offers a paid DMARC monitoring service that you can use to track your email sending reputation and proactively address any issues ($10/domain/month).
Support for webhooks for receiving and processing engagement and delivery events to synchronize with your system.

Postmark also offers a comprehensive dashboard that you can use to look at message-sending and engagement analytics data, as well as creating and maintaining email templates.

Pros

Deliverability. Postmark consistently has excellent inbox deliverability when compared to some of the other major providers referenced in this post. They relentlessly focus on having great deliverability for transactional emails, and run separate infrastructure for any bulk campaign messages to ensure your transactional emails get to your users' inboxes in a timely manner.
Visibility into time-to-inbox data. Postmark publish data on time-to-inbox, a metric that's tracked and aggregated across major email providers to document the time between sending an email and it being available within a user's inbox (i.e. delivered).
Great documentation and SDKs for all major languages. As a developer-focused tool, Postmark has a fantastic set of API documentation and guides, as well as a wide range of official and community-supported SDKs available for all major languages.

Cons

Lack luster templating. While Postmark does support some templating within their product, the offering is less robust than some of the other services listed in this post (notably SendGrid and SparkPost) given they don't offer a visual, drag-and-drop editor.

Postmark pricing

Postmark offers a simple tiered-volume pricing that's billed monthly. Each plan tier includes a base amount of emails per month, and overages are charged by the thousand at a sliding scale depending on the volume sent. There's also a free developer plan that provides 100 test emails every month for free if you want to try out the service.

Dedicated IP addresses are available for customers sending over 300,000+ emails a month for $50/month.

AWS Simple Email Service (SES)

AWS Simple Email Service (SES) touts itself as "a cost-effective, flexible, and scalable email service". It's a product offering from Amazon Web Services and is designed to send high volumes of transactional emails. AWS SES is lighter on features than some of the other services we're comparing in this list, but if you're already deployed within AWS or use any other products within the AWS suite it might be worth considering as an option.

AWS SES Features

Inbound (receiving) and outbound (sending) are supported via the API and SDKs.
Attachments are supported via the raw email sending API.
Options for static IPs including shared, bring your own, and dedicated IP addresses.
DKIM, DMARC and SPF supported.
Tight integration with other AWS services such as EventBridge and Cloudwatch.
Support for tracking deliverability metrics such as bounces, complaints, and delivery rates.

Pros

Deliverability at an enormous scale. SES sends hundreds of billions of emails a year for some of the largest internet companies on earth, such as Netflix, Reddit, and Amazon.
SDKs in all major languages. The AWS SDK is available in all major server-side languages along with thorough accompanying documentation.

Cons

Setup is complex. As is the case with many AWS services, getting started with SES can be daunting. The documentation and examples often leave a lot to be desired, with auto-generated SDKs and docs making it difficult to understand exactly how the API works.
All accounts are initially sandboxed. This limits initial sending to 200 messages in a 24-hour period, with restrictions on who can be sent an email (allow listed domains and email addresses). The sandbox restriction can be removed from the SES console.
Accessing analytics data is non-trivial. To access analytics data (opens, link clicks, deliverability metrics) you need to add an SNS topic to route all events through and then have a destination (like a lambda function) to process the event.

AWS SES pricing

AWS SES is one of the cheapest options for sending emails out there. If your application is already hosted in AWS, then the first 62,000 emails sent each month is free. Beyond that volume emails are priced at $0.10 for every 1,000 emails sent and $0.12 for each GB of attachment data. On the inbound side, the first 1,000 emails are free and then it's $0.10/per 1,000 emails received.

As an aside, it's important to note that with SES, like most AWS services, you will pay for outgoing data and transfer fees:

“You pay for outgoing mail data, incoming mail chunks, and EC2 data transfer fees—even if your usage of Amazon SES qualifies for the AWS Free Usage Tier.“

Pricing with SES can get complicated, so it's probably best if you use the AWS SES pricing calculator to understand exactly how much the service will cost you.

Mailgun

Mailgun from Sinch is a well-established, developer-focused email service that's been in business since 2010. It powers email delivery for some large, well-known companies including Lyft, American Express, and Wikipedia. As a developer-focused tool, Mailgun is fast to get started with and integrate into your product. It's an excellent offering if you're looking for a reliable, easy-to-use product.

Mailgun features

Comes with outbound (sending) and inbound (receiving) APIs.
Supports attachments via easy-to-use, base64 encoded content.
DKIM, DMARC and SPF supported.
Support for dedicated IP addresses and dedicated IP address pools on higher tiers of sending.
Has advanced features such as send time optimization.
Both EU and US-specific sending regions.
Email address verification tools. Note: these are charged separately from your email sends.
Support for webhooks for receiving and processing engagement and delivery events to synchronize with your system.

Additionally, Mailgun also comes with a dashboard that you can use to look at emails sent and analytics around engagement and delivery data. The dashboard also allows you to create and maintain email templates using the visual email editor available via Mailjet.

Pros

Excellent documentation. As a developer-focused offering, Mailgun has a very well-written set of documentation and guides.
Robust support for deliverability. Mailgun prides itself on its commitment to deliverability with services to pair you with an email expert to ensure you're achieving exceptional deliverability. There's even a great section in their documentation for email best practices for deliverability and sending health.

Cons

Lack of SDK support. Mailgun has SDKs available in most major languages but has some notable exceptions for their official SDKs including Python, Node, and Elixir.

Mailgun pricing

Mailgun comes with a generous trial tier that includes 5,000 emails included for the first 30 days. Extra sending volume is purchased in blocks of $1.00 per 1,000 messages. There are also paid tiers available that include a base amount of usage each month, with overages charged beyond the base amount. You can learn more and estimate your usage on their pricing page.

All Mailgun plans include 99.99% uptime, 24/7 support, and analytics.

Resend

Resend is a new transactional email service that was in the W23 batch of Y Combinator. As a relatively new player in the email API space, the feature set offered is limited but the (excellent) team at Resend are shipping new features each week to build out the service.

Resend features

Outbound sending only (no inbound parsing, yet).
Attachments via easy-to-use, base64 encoded content.
Support for dedicated IP addresses via an add-on.
DKIM and SPF supported.
Created and maintain react email, a transactional email building framework for React.

Resend also comes with a dashboard that you can use to configure the service, view some statistics about the number of messages sent, see API logs for inbound requests, and logs of messages generated.

Pros

Beautiful documentation and guides. The Resend documentation is well-made, easy to follow, and showcases the team's attention to detail with all things developer experience.
Deep integration with React. If you're looking to write transactional email templates in React, there's no easier way to send those emails than with Resend's JavaScript SDK.

Cons

No templating support. Unlike a lot of the other email services in this list, there's no option in Resend to manage templates inside of the dashboard and reference them from the API. This might not be a deal-breaker however, as long as you're comfortable maintaining your templates in your codebase.

Resend pricing

Resend offer 3 pricing tiers: Free, Pro, and Enterprise. The free tier comes with 100 emails a month which must be sent from a verified sender. The pro tier offers a usage based plan, where 50,000 emails is $20/month. Each plan comes with different lengths of data retention for sent messages and logs. The Pro plan can be upgraded with a dedicated IP for $30/month, while the Enterprise plan comes with dedicated IPs out-of-the-box.

Mailchimp Transactional Email (formerly known as Mandrill)

Mailchimp Transactional Email is an email service that's an add-on to the ever popular marketing tool, Mailchimp. It used to be called Mandrill, but in recent years has moved from a standalone service offering to a paid add-on where you must have an existing Mailchimp subscription and plan to use the service. As such, it's an ideal offering if you're an existing Mailchimp customer.

Mailchimp Transactional features

Comes with outbound (sending) and inbound (receiving) APIs.
Supports attachments via easy-to-use, base64 encoded content.
DKIM, DMARC and SPF supported.
Support for dedicated IP addresses.
An advanced rules engine to apply rules to inbound or outbound emails.
Webhooks for email events, so you can respond to engagement and delivery events in real-time from your system.

Pros

Excellent documentation. Mailchimp has some of the friendliest and best laid out developer documentation out there, making it really easy to get up-and-running and find answers to any questions about the service.
Strong focus on deliverability and speed of delivery. Mailchimp has a set of global infrastructure that's employed to deliver emails quickly, while ensuring great deliverability. There's also support for IP address warming, dedicated IP addresses, and IP address pools.
Solid analytics and reporting capabilities. The dashboard has the ability to pull reports on deliverability, opens, clicks, bounces, and rejections. There are also logs that can be searched for outgoing messages by tags and subject lines.

Cons

Requires an existing Mailchimp subscription. As mentioned above, Mailchimp transactional requires an existing Mailchimp Standard or Premium subscription in order to purchase the add on and start sending transactional messages.

Mailchimp Transactional pricing

Mailchimp's Transactional pricing is based around the concept of blocks, where each block is a credit for 25,000 emails. Blocks are charged on a sliding scale, where the more blocks that are purchased the lower the cost per block. For example, to send 100,000 emails a month the cost will be $80. In addition, there's also a free plan available to new transactional email users with 500 free email sends included to a verified domain, and you can purchase a dedicated IPs for $29.95/month.

Please note: you will need a Mailchimp account on the Standard or Premium plan to use Mailchimp Transactional Emails.

SparkPost

SparkPost is an enterprise-grade email service from MessageBird that sends 37% of all emails for B2B and B2C applications. It's used by Twitter, Pinterest, and Zillow to reliably send and deliver emails. Although SparkPost is an enterprise-grade service, it's also accessible to teams at all sizes and prices very competitively.

SparkPost features

Comes with outbound (sending) and inbound (receiving) APIs.
Supports attachments via easy-to-use, base64 encoded content.
DKIM, DMARC and SPF supported.
Dedicated IP addresses, IP address pools, and IP address warming.
Support for webhooks for receiving and processing engagement and delivery events to synchronize with your system (note: there are a limited number of available webhooks on the starter and premier plans).

Pros

Support for subaccounts. If you have multiple applications that need isolated sending streams, but you want to bill them under a single consolidated account, then SparkPost's subaccounts are a useful feature.
On-premise mail sender. SparkPost is the only provider that offers an on-premise mail sending solution for very high volume workloads.
Great analytics tools. SparkPost includes a whole host of analytics tools to understand delivery rates, including a predictive health score for your emails.
Excellent template management tools. There are a whole suite of template management tools built into SparkPost.

Cons

Hard-to-navigate documentation. While SparkPost has pretty comprehensive documentation, it's not always easy to navigate around find the specific answers your looking for. The getting started guides are also less comprehensive and beginner-friendly than some of the other services mentioned in this article.

SparkPost pricing

SparkPost offer 3 tiers of pricing: Starter, Premier, and Enterprise. There's also a free developer trial available that can be used to try out features before signing up for a paid plan. The Premier and Enterprise plans are available when your monthly volume exceeds 100,000 emails/month, with both including a Dedicated IP address as part of the plan. For much higher volumes, an Enterprise plan is available.

Using Knock to build a transactional notification system

Adding transactional email support to your product is usually one of the first steps to building out more notifications from your product, but before long you may find yourself in the weeds building lots of different types of notifications across disparate channels. This is where Knock can help.

Knock is a developer tool for building cross-channel notification systems. With Knock, you can create complex cross-channel notifications for your product without writing complex notification code yourself. You call Knock's API and you can send notifications to in-app and out-of-app channels such as email, push, SMS, and Slack.

Even if you're only planning on sending emails from your product, Knock can help. You can use Knock's dashboard to collaboratively manage your email templates, either with a drag-and-drop visual builder or by dropping down to writing HTML. Knock also takes care of all of your retry and delivery logic, as well as batching (collapsing multiple notifications about a single topic into one), managing per-user notification preferences, and providing unparalleled visibility into the notifications your product is sending.

If you'd like to try it out, you can sign up for a free account or chat with our team. 👋

📈 A/B testing with limited data at a startup

Colin White — Fri, 23 Mar 2018 18:12:39 +0000

Originally posted on Manifold

📈 A/B testing with limited data at a startup

Practically every article you read about startup marketing stresses the importance of A/B testing. From the header on your landing page to the colour of your signup button, even the most minor thing should be tested. But, almost all of these articles you’re reading assume one thing. That you’re in growth mode.

But that’s an issue for a lot of companies.

Startups that haven’t hit growth just don’t have enough data to run A/B tests at scale. This means that testing at low numbers is a completely different ballpark than when you are scaling. I’m not saying that it’s impossible, but I’ll break down some common misconceptions and mistakes that are easy to make when testing with small amounts of data.

Let’s quickly define A/B testing

A marketing experiment where two variations of a landing page, ad, email or other piece of online content are pitted against each other to determine which produces the highest conversion rate.
https://unbounce.com/conversion-glossary/definition/ab-testing/

That’s the definition from a marketers point of view. Pit two pieces of marketing material against each other to see which converts better. This definition doesn’t do justice to the statistical methods behind A/B testing.

When you run an A/B test, you are most likely doing a comparison of two binomial distributions using some type of statistical test (there are a few possibilities).

Things like click-through rates or conversion rates are binomial distributions.

If you are using A/B testing software like Optimizely, a lot of these statistics are hidden from you, which can sometimes be to your detriment.

A/B testing pitfalls

Testing software makes running experiments approachable to all types of people. You really don’t have to know much about statistics to pull off an A/B test in Google Optimize or Optimizely. But not having much knowledge in stats can lead you down the path to some easy to avoid mistakes.

Let’s look at a few.

Ending your test too early

If you’re like me, you LOVE watching the numbers go up when you’re running experiments (or ads, or anything). And one of the best numbers to watch is what most A/B testing software has now. The “chance to beat” metric. This is a number that the software calculates on the fly using a multitude of variables available.

This number can be misleading. If your “chance to beat” is at 100% you might be thinking, “alright, let’s end this and start the next test”, but that can get you into major trouble. This is called peeking. Peeking is when you look at the data before you’ve gathered a big enough sample size and means you haven’t hit statistical significance. Following the process of ending your tests early can lead to false positives that aren’t going to be correct in the long run.

Running A/B tests takes a lot of traffic, especially as you get further into your funnel. Users drop off and you get less and less people seeing your test.

Let’s look at an example. Say you have a conversion rate on a landing page of 5% and you want to get it up to 5.5%. That’s a 10% increase. Seems pretty reasonable to get there. But to be confident in that change to the landing page, you’ll need each variation to get a sample size of ~30000 visitors.

I don’t know about you, but getting ~60k visitors to a landing page can be pretty tough when you are early in your startup’s lifecycle.

Checkout Evan Miller’s awesome sample size calculator to better understand the audience size you need: https://www.evanmiller.org/ab-testing/sample-size.html

Not understanding your audience

Not all visitors to your website are the same. As marketers & founders, we know motivation and intent are key to marketing proficiently.

A/B testing is the same. If you are running a test that needs 10000 sessions per variation and all of a sudden get 20k hits to your landing page because a blog post blew up. Is that really a good sense of what your conversion rate is going to be? Probably not. You need to make sure you understand who is visiting your site before you can make a call.

Sometimes it’s worth running a test to a higher significance if you’re not confident you’re sample has a decent diversity.

Testing all the small things

I hope you don’t have blink 182 in your head now.

I’ve talked a lot about the sample size that’s needed to run tests. In some cases it’s huge. And one of the biggest contributors to your sample size needed is the percent lift you want to see.

Let’s go back to the example above of our 5% -> 5.5% conversion rate. Testing to significance for that example, we would need to have around 30k visitors per variation. But say we wanted to see that conversion rate lift to 6% instead by changing the whole landing page and not just the CTA copy. That drops our visitors needed per variation down to ~12k. That’s half the visitors and a much more achievable number.

Making large changes to whatever you are testing is important when you you can only muster a small sample set. If you are changing something small, you won’t be hypothesizing a large lift in your test variable. But, if you make large changes to your content and go for a higher change in the test variable, your sample size needed will decrease dramatically.

Don’t just go and boost your goal lift to a crazy amount here. You still need to think of testing in a scientific way and choose all of these metrics based on a good hypothesis. Otherwise you are never going to hit significance and you’ll never learn anything.

Testing is hard

And it’s even harder at a startup. Tools like Optimizely and Google Optimize are making it easier and easier to run experiments, but they don’t give you all of the background math that needs to be done. Not knowing those statistical methods that are running in the background can lead you to false positives.

Make sure you’re setting your sample size before your test and sticking to it. Don’t call a test done just because it looks like it’s going to win. Remember, data trumps gut if you have it. Watch out for traffic spikes from one spot, it can make your audience less diverse and skew your results to the max. And lastly, don’t test the small things when your throughput is low. If you’re looking to see significant results at low sample sizes, make big changes. Switch out the landing page for a completely different one, or completely change up the ad you’re running, not just a few words.

Feel free to hit me up at colin@manifold.co if you have any questions, I love to chat about this stuff.