How to use AI to automate account research and drive more sales

Our goal here is simple: reduce the huge time commitment to research accounts for sales without sacrificing high-quality account information.

SEC filings, specifically the Form 10-K filing, have rich information about each public company’s financials and commentary on their forward strategy. Anyone can glean great information from these reports, but manually reading through these long documents would be a huge time commitment.

AI large-language models (LLMs) are a natural solution to digest and synthesize these standardized reports. We built a solution with Hightouch and an open source LLM API to create automated, bulleted summaries of the key information relevant to our sales team.

The solution we built, tested, and now use works in four steps:

1. Use Hightouch to build a data model to power AI: We created a model in Hightouch that returns every new account that is added to our Salesforce Account-Based Marketing campaign. The returned rows will be the data that power our asks to the LLM API.
2. Write a serverless function that uses the LLM API: This function triggers an AI API prompt to find Form 10-K for each company, returns the top marketing pain points for that company, and then writes the response back to Snowflake.
3. Trigger the serverless function with a Hightouch sync: Once we had a model that included the accounts we wanted for and built the serverless function to call the AI API, we triggered the serverless function for each account using a Hightouch sync.
4. Sync the serverless function’s outputs to Salesforce. This sync takes the responses from the AI response and adds them as a note attached to each account in Salesforce.

This automation now allows our sales team to skip the account research and simply look at each account in Salesforce to get a bulleted list of pain points they can use to pitch customers on our product.

Next, we’ll take a deep-dive into each step. While this use case is pretty specific, what is exciting is that this architecture unlocks the ability to take any Snowflake data, use it in an AI request, and then send the response to any of your SaaS tools for future reference or to power workflows!

In order to power an API call to any LLM, we needed to first generate a data model that contains the key information we’ll use in the call.

For our use case, the model has three requirements:

1. It needs to return new rows whenever we add an account to target in Salesforce
2. It needs to return company name and domain to use in the AI prompt
3. It needs to return the account ID to be used in the writeback to Snowflake, so that we can ultimately connect the output of the AI model back to the original Salesforce account.

Here’s an example query to create the model:

select 
account_id,
account_name,
clean_website

from salesforce.campaign_members
left join salesforce.accounts on member_id = account_id

where campaign_id = 'xyz'

We next built a serverless function that ultimately runs prompts in the open-source LLM API and writes the results back to our warehouse. The serverless function has a few key steps:

1. Ingest data from our model including company domain, account id, and account name. We store the columns as variables and then lightly clean them.
2. Trigger an API call to prompt the LLM API using the variable for account name. An example prompt is: “"Summarize the marketing painpoints of {account_name} based on their latest 10k filing or equivalent public document".format(account_name)". The AI responses were actually brilliant and super useful (see the end of this article for an example)!
3. Use Snowpark to insert a row into a Snowflake table that contains two columns. The first is the Salesforce Account ID and the second is the response that the LLM generates.

Now that we have a serverless function that can run AI prompts with the inputs from our data model, we have to automatically send new rows to this serverless function whenever we add accounts. This means that whenever we start a new campaign for account-based marketing, we’ll automatically run our serverless function.

We built a sync with Hightouch from our model directly to this serverless function, so that we can add new rows to it. A few things we had to keep in mind:

• We limited this to only send two requests per minute to avoid any rate limits and avoid any issues with the LLM API taking too long to generate a response.
• We also elected to send all columns from the model in a JSON payload, as this is what the serverless function we wrote expects and we had already done the column filtering on the model side.

All of these settings are configurable in the Hightouch UI, so you could easily include more fields or trigger a function with different frequency requirements.

Now, we have a Snowflake table with each of our target accounts and the response from the AI prompt. The final step is to sync this, using Hightouch, to a note attached to each account in Salesforce, so that our sales team can leverage it.

1. We created another model in Hightouch that selects everything from our response table.

   

2. We created a sync from this model to Salesforce. This inserts a note onto each account record in Salesforce.

This use case and architecture began as a fun internal experiment but turned out to be extremely useful for our reps.

What makes this really exciting is that we can cut and paste this workflow to take any data from Snowflake, create an AI powered prompt, and then use Hightouch to send the response to any downstream tools to then be used later on. Endless possibilities!

Here’s an example of one of our summaries: