# Best Practices: Optimizing Your Email Outreach
## Sequence Copy
1. **Keep an individual sequence to 4 email touches max -** Within a four-touch sequence, we recommend alternating the structure between 2 new threads and 2 follow-up replies. The copy of these follow-up replies can be short and limited to 1-2 sentences. Example: "Any thoughts on my previous note?"
2. **Alternate case studies and value props between new threads -** You should vary the copy and angle you're approaching to pitch your product in email steps 1 and 3. For example, you can highlight different customer case studies or statistics across both emails.
3. **Shorten subject line and use personalization -** Keep subject titles concise and add custom variables to increase variability. This approach will also help improve deliverability. Example: "Unify x (Your Company Name)"
4. **Include statistics and case studies for social proof -** Incorporating very numbers-driven, concise impact statements can catch your prospect's attention. We recommend adding concise blurbs from customer case studies into your sequence copy.
5. **Add personalization with snippets -** You can use Unify's smart snippets to personalize copy based on relevant value prop, job title, work description, industry, and more. This will make your sequence copy more compelling with targeted pain points, use cases, or case studies. More variance in email copy will also help with deliverability.
6. **Keep it concise, focus on a single product or pain point -** Don't try to fit too many points into your email - you want to be decisive and mention the most relevant product or pain point to that individual to capture their attention! Keep the language simple and avoid business jargon. We generally recommend keeping each email between 50-200 words.
7. **End with a compelling call to action (CTA) -** Conclude each email with a clear, specific, and actionable request. This could include scheduling a call, booking a demo, or asking the prospect to reply with a specific piece of information relevant to their needs.
## Deliverability
1. **Limit the links -** Try not to overload your emails with multiple or duplicate links. Too many links can set off spam alarms - we generally recommend limiting the email touch to include 1-2 links maximum.
2. **Check link safety -** Ensure the links you include are secure and no warnings are displayed by the browser when visiting them.
3. **Mix up subject lines -** Don't stick with the same old subject lines, use template variables to keep them dynamic and interesting.
4. **No all caps -** Using all caps anywhere in your email can make it look spammy, so stick to normal capitalization.
5. **Easy on the exclamation -** Too many exclamation points can trigger spam filters, especially in the subject line. Use them sparingly!
6. **Send from multiple email addresses -** Sending emails from multiple mailboxes improves deliverability by distributing volume across different IP addresses and domains. This approach reduces the risk of being flagged as spam and increases overall sending capacity.
7. **Proofread for Typos**: Typos can make your email look unprofessional, especially when you're emailing multiple contacts at a company. Make sure to proofread and catch any errors.
# Best Practices
Unify's recommendations for high-performance GTM.
Learn how to use plays effectively to automate your outbound.
Design your sequences to maximize response rates and deliverability.
# Best Practices: Plays to Book You Meetings
## Section 1: Best Practices
Unify is a sales engagement platform designed to help you generate pipeline. To ensure that you see the best results, we recommend a few general principles:
* **Act Quickly:** Act on intent signals within 24-48 hours to catch prospects before they make their decision. Intent gets stale quickly.
* **Engage with Every Lead:** Once you define your ICP in Unify, avoid selective outreach. Avoid introducing bias into how you prospect.
* **Multiple Touchpoints:** If you’ve found that a channel works best for your team, use Unify to lean into that. Unify excels at email - if that’s your preferred channel, great. If not, use email in addition to LinkedIn or phone outreach. See section 4 below to see our recommendations for email and LinkedIn outreach.
## Section 2: Actioning on Intent
There are two primary ways to act on intent data in Unify:
### Automatic Plays
* **When to use:** Both for low and high volume signals. Plays automate prospecting, qualifying, sequencing, and syncing leads to your CRM.
* **Benefits:** Reduce friction and improve intent to meeting booked conversion by immediately actioning on leads.
* Learn more about how to build Plays in [How to Create a Play](/tutorials/how-to-create-a-play).
### Manual Alerts
* **When to use:** Ideal for low volume, high value signals. It's important to ensure the sales team is accountable for acting on alerts to ensure hot leads don’t slip through the cracks.
* **Benefits:** Immediate and contextual information delivered to where your team is working.
* Most reps use Slack alerts or custom Zaps to trigger manual workflows. Learn how to set these up in our [Slack Integration Guide](/tutorials/how-to-set-up-slack-alerts) and [Zapier Integration Guide](/reference/integrations/zapier).
## Section 3: Intent-Based Plays
Intent signals are indicators that there’s an opportunity to sell your product or book an intro meeting. Our customers have seen success with these intent-based Plays:
1. **Pricing Page Visits:** Checking out pricing pages indicates that prospects are seriously considering a purchase decision.
2. **[Repeat Buyers](https://www.unifygtm.com/plays/champion-tracking---outbound-to-past-customers-who-have-moved-jobs):** When someone you’ve sold to before is back on the website demonstrating high intent. This works well for businesses that have more transactional sales.
3. **[Inbound Form Submissions](https://www.unifygtm.com/plays/outbound-to-website-form-submitters):** A form submission is one of the strongest signs of intent. Convert those leads immediately by automating outreach as soon as they submit.
4. **[New Hires](https://www.unifygtm.com/plays/outbound-to-people-who-have-started-jobs-at-a-new-company):** People are more likely to purchase new tools in their first few months on a job. Targeting your ICPs that have just changed jobs can convert better.
5. **[Support Docs](https://www.unifygtm.com/plays/outbound-to-contacts-viewing-your-technical-docs):** Interest in support docs (e.g., integration details), suggests prospects are trying to understand how your product works and if it would work for them.
6. **[Social Content Engagement](https://www.unifygtm.com/plays/automate-outbound-to-linkedin-likers-commenters)**: Liking or commenting on your social posts signals that a prospect is interested in your company.
7. **[Product Tour Visits](https://www.unifygtm.com/plays/outbound-to-people-who-view-your-product-demo):** Interest in demo videos or product tours indicates a desire to understand specific product offerings in more granularity.
8. **[Retarget Paid Traffic](https://www.unifygtm.com/plays/retarget-paid-traffic):** Get more out of your spend on paid traffic by retargeting people based on UTM filters.
9. **[Closed-Lost Opportunities](https://www.unifygtm.com/plays/retarget-closed-lost-opportunities-when-they-revisit-website):** A revisit to your site by a closed-lost opportunities signals the prospect might be interested in re-engaging.
## Section 4: Section 4: Nailing Email or Linkedin Outreach
Nailing email and LinkedIn messages is key to booking the most possible meetings from Unify. A few guiding principles:
1. **Use Soft Messaging:** Use your judgement, but we typically recommend against direct mentions of website activity. Instead, tailor messages to address the pain points related to the product or service they showed interest in.
2. **Keep It Short:** Many senior leaders at your target accounts read emails on their phones, concise messages under 100 words are more likely to be read and understood. Remember that people are skimming emails.
3. **Persona-Specific Messaging:** Address specific pain points and perspectives of the different personas you sell to (e.g., sales and marketing for us). Avoid generic messages that try to cater to multiple personas, as they may resonate with none.
4. **Focus on One Product:** If you sell multiple products, pitch one per email. This approach minimizes the chances that your prospect gets confused about what you solve.
5. **Highlight Relevant Pain Points:** Rather than pitching your product, focus on speaking to a specific challenge or pain point that your prospect has. Educate the prospect on your product once you’re on the phone with them.
# Intent Client Usage
Learn how to send events using the Unify Intent Client.
The Unify Intent Client can be used to log user activity across multiple subdomains of the
same top-level domain. For example, if a user visits your marketing website at `www.yoursite.com`
and then logs into your production web application at `app.yoursite.com`, the activity in both
places will be attributed to the same person.
## Page View Events
Website page views are an indicator of buyer intent. You can log this information to the Unify platform
for usage with the `page` method.
There are two ways to collect page data with the Unify intent client:
1. Automatic monitoring of the current page
2. Manually via the client `page` method
Utilizing both of these methods when appropriate is recommended to take full advantage of intent data
within Unify.
### Automatic Page Monitoring
The Unify intent client is capable of automatically monitoring the user's current page to trigger
page events. This will happen by default when the client is installed via the [Unify Website tag](./website-tag).
If the client is installed via a package manager, you must pass the `autoPage` configuration option
when instantiating the client. See [Configuration](#configuration) below for more details.
Automatic page monitoring works in Single Page Apps, too!
In either case, this behavior can be enabled or disabled programmatically via the `startAutoPage`
and `stopAutoPage` methods on the client:
```ts
// Initialize the client and tell it to automatically monitor pages
const unify = new UnifyIntentClient(
'YOUR_PUBLIC_WRITE_KEY',
{ autoPage: true },
);
unify.mount();
// Tell the client to stop monitoring pages
unify.stopAutoPage();
// Tell the client to start monitoring pages again
unify.startAutoPage();
```
### Manual Page Logging
You can also manually trigger a page event with the `page` method on the client. This is useful
when you do not want to trigger page events for every page.
```ts
const unify = new UnifyIntentClient('YOUR_PUBLIC_WRITE_KEY');
unify.mount();
// Trigger a page event for whatever page the user is currently on
unify.page();
// Trigger a page event for a custom page other than the current page
unify.page({ pathname: '/some-custom-page' });
```
## Identify Events
All intent data collected for users by Unify is anonymous by default. When intent events are
logged, Unify will attempt to automatically de-anonymize the IP address of a user to associate
them with a specific company, but their personal identity will remain anonymous until an
identify event is triggered for them.
There are two ways to collect identity data with the Unify intent client:
1. Automatic monitoring of email input elements
2. Manually via the client `identify` method
Utilizing both of these methods when appropriate is recommended to take full advantage of intent
data within Unify.
### Automatic Input Monitoring
The Unify intent client is capable of automatically monitoring text and email input elements on
the page to collect user identity. This will happen by default when the client is installed via
the Unify JavaScript tag. If the client is installed via a package manager, you must pass the
`autoIdentify` configuration option when instantiating the client. See [Configuration](#configuration)
below for more details.
In either case, this behavior can be enabled or disabled programmatically via the `startAutoIdentify`
and `stopAutoIdentify` methods on the client:
```ts
// Initialize the client and tell it to automatically monitor inputs
const unify = new UnifyIntentClient(
'YOUR_PUBLIC_WRITE_KEY',
{ autoIdentify: true },
);
unify.mount();
// Tell the client to stop monitoring inputs for now
unify.stopAutoIdentify();
// Tell the client to start monitoring inputs again
unify.startAutoIdentify();
```
### Manual Identification
You can also manually trigger an identify event with the identify method on the client. This is
useful when users log-in with OAuth or SSO, for example, because they do not enter their email
into an input on the page.
```ts
const unify = new UnifyIntentClient('YOUR_PUBLIC_WRITE_KEY');
unify.mount();
// However you determine the currently logged-in user
const currentUser = getCurrentUser();
// Identify the current user
unify.identify(currentUser.emailAddress);
```
## Configuration
The following configuration options can be passed when initializing the client:
If installed via the [Unify Website tag](./website-tag) then the `autoPage` config will default to `true`.
Tells the client to automatically log page events whenever the current page changes.
Works for static websites and Single Page Apps. Also logs a page event for the initial page.
If installed via the [Unify Website tag](./website-tag) then the `autoIdentify` config will default to `true`.
Tells the client to automatically monitor text and email input elements on the
page for changes. When the current user enters a valid email address into an input, the client
will log an identify event for that email address.
# JavaScript Client
Install the Unify Intent client in a frontend web application framework.
## Installation
You can install the Unify Intent JS Client with your preferred package manager:
```shell npm
npm install @unifygtm/intent-client
```
```shell yarn
yarn add @unifygtm/intent-client
```
```shell pnpm
pnpm add @unifygtm/intent-client
```
## Usage
After installing the client, you must initialize it in your application code:
You should only initialize the client one time in your application.
```ts index.ts
import { UnifyIntentClient, UnifyIntentClientConfig } from '@unifygtm/intent-client';
const writeKey = 'YOUR_PUBLIC_API_KEY';
const config: UnifyIntentClientConfig = {
autoPage: true,
autoIdentify: false,
};
const unify = new UnifyIntentClient(writeKey, config);
// Do not call mount during server side rendering. Only call it in a browser context.
unify.mount();
```
You can then use the resulting client instance to log intent data. See the
[Client Spec](./client-spec) for more details on how to use the client.
## Cleanup
When you are done using the client, if you wish to clean up the side effects
generated by it, you can do so with the `unmount` method:
```ts cleanup.ts
import { UnifyIntentClient, UnifyIntentClientConfig } from '@unifygtm/intent-client';
const writeKey = 'YOUR_PUBLIC_API_KEY';
const unify = new UnifyIntentClient(writeKey);
unify.mount();
// Use the client for some time, then later...
unify.unmount();
```
# Intent Client Overview
Learn how to start collecting website intent data in Unify.
Buyer intent data is at the core of what makes Unify tick. The easiest way to
start collecting this data is by installing the Unify Intent client on your
marketing website or web app.
# How it works
The Unify Intent client is a JavaScript library that allows you to collect
events from your website and send them to Unify. It supports collecting three
types of events:
e.g. a user visits the pricing page of your marketing website
e.g. a user logs into your web application with their email address
e.g. a user clicks a button to open a pricing calculator modal
When you install the Unify Intent client on your website, it can automatically
start collecting these events and sending them to Unify. You can also customize
this behavior by sending events manually using the client's API.
The Unify Intent client is fully open source and available on [GitHub](https://github.com/unifygtm/intent-js-client).
# Installation
There are several different ways to install the Unify Intent client on your
website. Choose the one that best suits your use case:
Quickly set up the Unify Intent client on a static marketing website.
Install the Unify Intent client in a React app.
Install the Unify Intent client in a different frontend web application
framework.
If you aren't sure, we recommend starting with the **Website Tag** installation
method. This is the simplest way to get started and all you need for most
marketing websites.
# Usage
If you install the client using the **React Library** or **JavaScript Client**
methods, see our [Usage Guide](/developers/intent-client/client-spec) to learn
how to use the client and start adding events.
# React
Install the Unify Intent client in a React app.
## Installation
You can install the Unify Intent React library with your preferred package manager:
```shell npm
npm install @unifygtm/intent-react
```
```shell yarn
yarn add @unifygtm/intent-react
```
```shell pnpm
pnpm add @unifygtm/intent-react
```
## Usage
First, wrap your React app in a `UnifyIntentProvider`:
```tsx index.tsx
import {
UnifyIntentClient,
UnifyIntentClientConfig,
UnifyIntentProvider,
} from '@unifygtm/intent-react';
const writeKey = 'YOUR_PUBLIC_API_KEY';
const config: UnifyIntentClientConfig = {
autoPage: true,
autoIdentify: false,
};
const intentClient = new UnifyIntentClient(writeKey, config);
const root = ReactDOM.createRoot(
document.getElementById('root') as HTMLElement,
);
root.render(
);
```
The `UnifyIntentProvider` automatically takes care of mounting and unmounting the client
for you whenever the component mounts and unmounts. So any components rendered in your app
can freely access and use the intent client using the `useUnifyIntent` hook:
```tsx Example.tsx
import { useUnifyIntent } from '@unifygtm/intent-react';
const Example = () => {
// Get the Unify Intent Client
const unify = useUnifyIntent();
// However you access the current user...
const currentUser = useCurrentUser();
useEffect(() => {
if (currentUser?.emailAddress) {
// Log an identify event for the current user
unify.identify(currentUser.emailAddress);
}
}, [currentUser, unify]);
...
};
export default Example;
```
You can then use the resulting client instance to log intent data. See the
[Usage](./client-spec) page for more details on how to use the client.
# Website Tag
Quickly set up the Unify Intent client on a static marketing website.
# Installation
You can automatically load and install the client by placing a `