Building account-based marketing segments from company signals

An account-based marketing segment is a list of company domains, each with a reason it is on the list. This guide gives six recipes that pair fit (who the company is and what it runs) with timing (what it has just done), written against the Technology Stack, Technology Changes, Website Profile, Hiring Activity, Intent Scores and Company Funding datasets, then the measures that show whether a segment earns its budget and the routine that keeps it current.

A segment is fit plus timing

Fit moves slowly: what the company is and what its website runs. Timing moves fast: dated events in the last weeks. Fit decides who may be in a segment, and timing decides who is in it this week and how hard you work the account.

A list with fit only is a target list that never changes, and a list with timing only is a stream of events with no filter for who matters. Keep both, and keep the reason. A segment row is a domain, a company_id, the segment name, the reason in words and the date the account entered.

Two points shape every recipe. Fokals is company-level data, so a segment is a list of companies, and the people come from your CRM or from the matching your ad platform does on the domains you upload. And Fokals is delivered direct, by REST API and as bulk files: you export the list as domains and load it into your CRM or ad platform with its own upload tool.

What fit can be built from

Fit comes from columns that change slowly. The website labels, among them industry, business model, target customer size and growth stage, sit in the dashboard and the data browser. A segment built from files starts from the columns below, and one built in the dashboard can use the labels as well. The marketing stack dataset holds the Technology Stack (company_technologies) and the Website Profile (company_site_facts), and every column is defined in the data dictionary.

Six recipes

Each recipe is a fit rule and a timing rule. The timing windows are starting points to tune against your own results.

Fit with no timing signal belongs in an evergreen tier. It gets low-cost channels only, so that paid spend lands where timing exists. The timing columns live in Hiring Activity and Intent Scores, part of the hiring and intent datasets, as well as in Technology Changes (company_tech_events) in the marketing stack.

One recipe in full

The stack gap recipe reads the Technology Stack, Technology Changes and Hiring Activity, with two timing signals and three tiers. It assumes JSON cells are loaded as jsonb and empty cells as null. The technology id, the category and the function are placeholders for yours.

with fit as (
  select distinct a.company_id, a.domain
  from company_technologies a
  where a.technology = 'complement_id'
    and a.missing_since is null
    and not exists (
      select 1
      from company_technologies b
      where b.company_id = a.company_id
        and b.technology_category = 'category_you_replace'
        and b.missing_since is null
    )
),
adds as (
  select company_id, count(*) as tools_added_60d
  from company_tech_events
  where category = 'technology'
    and change = 'added'
    and observed_at >= now() - interval '60 days'
  group by company_id
),
hiring as (
  select company_id,
         coalesce((by_function ->> 'marketing_performance')::int, 0) as open_roles
  from company_hiring_daily
  where day = (select max(day) from company_hiring_daily)
)
select
  f.domain,
  f.company_id,
  coalesce(a.tools_added_60d, 0) as tools_added_60d,
  coalesce(h.open_roles, 0)      as open_roles,
  case
    when a.tools_added_60d > 0 and h.open_roles > 0 then 'tier 1'
    when a.tools_added_60d > 0 or  h.open_roles > 0 then 'tier 2'
    else 'tier 3'
  end as tier
from fit f
left join adds a   on a.company_id = f.company_id
left join hiring h on h.company_id = f.company_id
order by tier, f.domain;

Tier 1 holds the accounts with both signals, tier 2 those with one, and tier 3 is the evergreen tier. The row keeps the two counts so that the reason can be written into the first line of a message or the headline of an ad: a company that added an analytics tool last month and has two open performance marketing roles has told you what it is working on.

The intent surge recipe

The intent surge recipe reads Intent Scores (company_intent_weekly), one row per company, topic and closed week for topics scoring at least 5. A surge is a score of at least 50 that is at least double the company's own average for the topic over the previous twelve weeks, so it measures a change and not a level. Each row carries the evidence, the five strongest signals behind the score, each with its date, kind, source, weight and detail. Keep it, because it is the reason.

select
  w.company_id,
  w.topic_label,
  w.score,
  w.week_start,
  w.evidence
from company_intent_weekly w
where w.surge
  and w.topic in ('topic_one', 'topic_two')
  and w.week_start >= current_date - 14
order by w.score desc;

Pick the two or three of the 69 topics that your product serves, and read their ids from the topic and the topic label. Then read the evidence before you target. A surge built on a tool added shows a decision already made, and one built on roles that select tools or on a new initiative shows a decision being prepared. The first suits an integration or displacement message, the second an evaluation message. Exclude your current customers, whose own adoption of your product can raise the score.

The segment table

Keep one table for every segment you run, so that campaigns, reporting and the holdout all read from one place. Its columns are the segment row described above, with a tier and a date for leaving.

create table abm_segments (
  segment    text,
  company_id text,
  domain     text,
  tier       text,
  reason     text,
  entered_on date,
  left_on    date
);

An illustrative row: stack_gap for Acme Robotics, an invented company, in tier 1, with the reason "runs the complement, added a tool 18 days ago, two open performance marketing roles", entered on 16 September 2026. left_on stays empty while the account qualifies and is set when its timing signal ages out. The table gives you turnover, time in segment and the holdout flag without further work. The reason also chooses the message. A company that added a market gets the localisation story, and it does not need to be told that you watched its job board.

Judging a segment before you spend on it

• Size. Count the accounts and compare the figure with what the channel can carry. For personal outreach, that is as many accounts as your team can write to by hand each month. For an ad audience, it is enough accounts for the platform to match.
• Overlap. An account that appears in several recipes at once is the first to work.
• Turnover. The share of members that enter or leave each week. Intent signals fade by half every 30 days, so a timing rule turns over faster than a fit rule, and the programme should be as short as the rule is volatile.
• Recall against your wins. The share of your best customers that the fit rule would have included. If it leaves out half of them, the rule is wrong, however tidy the list.
• Result. Pipeline created per 100 accounts targeted, against a holdout: keep 10% to 20% of a segment unreached and compare. Without a holdout you measure the programme and the account's own momentum together.

Keeping it current

Run the build on a fixed cadence. Intent scores are written once a week for the week that closed, so a rule that reads them changes weekly at most. Events and postings arrive daily, so rules on them can run daily.

Record when each account entered and why. Remove an account when its timing signal is older than 90 days, the window the intent scores use, and apply the same exclusions every run: current customers, open opportunities and competitors. The scoring side is covered in prioritising accounts with intent scores, and setting the fit rule from your own customers in defining an ideal customer profile.

How to read the segments

• Company level. A segment names companies, and each carries the dated signals that put it there. Fokals intent is built from what a company does in public: a tool added, a role opened, a filing, an announcement, so every score points to evidence you can open.
• Match rate. An account you cannot match to a company ID is in no segment. Match on the domain first, report your match rate with every segment and review the unmatched accounts.
• Scores carry evidence. Every intent score names the dated signals behind it, so a rep or a campaign owner can open the source. Labels are produced under named, frozen versions, so a label means the same thing from one week to the next.
• What a detection means. A detection shows presence of a technology on the website. Treat it as a fact about the site, and pair it with a second signal when the decision is costly.
• The record. Every observation is dated and written once, never revised, so a timing recipe can be rerun on any past date and returns what was true then.

Frequently asked questions

The queries and code on this page are examples to adapt. Test them in your own environment before you rely on them.