TL;DR: Every LinkedIn post you publish generates engagement data that most marketers ignore. I built a system that automatically captures every engager, scrapes their professional profile, enriches the data into 10+ structured fields, and routes high-value contacts into my CRM. Here is the exact automation blueprint, including the module chains, the failure points, and what to do with the data once you have it.
The Data You Are Leaving on the Table
When you post on LinkedIn, you get likes, comments, and profile views. Most marketers treat these as vanity metrics. Maybe you screenshot a particularly good comment. Maybe you visit a few profiles. Then you move on to the next post.
Here is what you are missing: every single person who engages with your content just told you something about their role, their interests, and their buying intent. Someone from a target account liking your post about sales pipeline strategy is not just a like. It is a signal. But signals are worthless if you do not capture them.
I built a system that captures every one of those signals automatically. It watches my LinkedIn posts, scrapes engagement data via Apify, enriches each engager with full LinkedIn profile data, and builds a structured, ICP-scored contact database in Airtable. Zero manual research. Every engager captured. Here is exactly how it works.
The Two-Pipeline Architecture
The system runs two parallel pipelines that feed each other. Pipeline A handles post engagement collection. Pipeline B handles profile enrichment. Together they convert social media activity into a structured, sortable, actionable database.
Pipeline A: Engagement Collection
When I publish a LinkedIn post and log it in Airtable, the automation fires. Here is the exact module chain running in Make.com:
The trigger monitors my content database. When a post status changes to published, the scenario activates.
The scenario calls an Apify LinkedIn scraper actor configured to pull every like, comment, and reaction from the target post URL.
This is not optional. Apify runs take 30 to 90 seconds depending on engagement volume. Make.com will timeout and return empty data if you skip this step. The system waits, then fetches the completed dataset.
A feeder module breaks the Apify dataset into individual rows. Each engager becomes a separate record in Airtable with their name, LinkedIn URL, headline, and engagement type.
The module chain in Make.com looks like this: Airtable Trigger → Apify Actor (run) → Sleep (30s) → Apify Fetch Dataset → Feeder (split) → Airtable Create Records.
Pipeline B: Profile Enrichment
Pipeline A gives you names and LinkedIn URLs. Pipeline B turns those into a complete professional profile. This pipeline runs from either Google Sheets or Airtable, depending on the data source.
The enrichment pipeline watches a spreadsheet for new rows containing names and company information. When a new row appears, it fires a second Apify actor — the LinkedIn profile scraper — which pulls 10+ structured fields from each profile:
| Field | Source | Use Case |
|---|---|---|
| Current Title | Profile headline | Role fit scoring |
| Company | Current position | Account mapping |
| About Section | Profile summary | Personalization hooks |
| Location | Profile geo | Territory routing |
| Open to Work | Profile badge | Timing signal |
| Profile Photo | Avatar URL | CRM record enrichment |
| Contact info | Outreach routing |
The enrichment chain runs exactly the same sleep-and-fetch pattern: Google Sheets Watch → Apify Profile Scraper → Sleep → Fetch Dataset → Aggregate → Google Sheets Update. The aggregator module combines the scraped data and writes it back to the source sheet in structured columns.
Every field you would manually copy-paste from a LinkedIn profile — headline, about text, location, photo URL, open-to-work status — is captured automatically. A profile that would take you 3 minutes to research manually takes 45 seconds to enrich automatically, and you never touch it.
What You Do With the Data
Collecting engagement data is step one. The real work starts when you use it to prioritize who you talk to and what you say.
I route the enriched data into my Airtable CRM where each contact gets scored on role fit, company fit, engagement frequency, and signal strength. Someone who works at a target account, holds a decision-maker title, and has engaged with three of my last five posts is not just a random LinkedIn connection. They are a warm lead who has been signaling interest for weeks.
The system also handles company discovery in reverse. The Company-to-Contact Pipeline starts with a company name and uses Apify to find employees. The output routes through a job title filter that prioritizes decision-makers — VPs, Directors, Heads of — and skips individual contributors who are not in buying roles. Same pattern: Sheets trigger, Apify actor, sleep, fetch, aggregate, router. Different direction, same infrastructure.
“Every post you publish generates engagement. Every engagement is a signal. Every signal enriches your understanding of your audience. Running this manually means you capture maybe 5% of the signal. Running it as an automated pipeline means you capture all of it.”
What I Actually Think
Having run this system for over a year, here is what matters.
Sleep modules are infrastructure, not a hack. The first version of this pipeline failed silently for weeks because I had not built explicit waits between triggering the Apify actor and fetching the dataset. The scenario would fire, the actor would start, Make.com would immediately try to fetch results that did not exist yet, and the pipeline returned empty records. No error, no alert, just zero data. Adding a 30-second sleep module fixed it permanently. This is not a workaround. It is how asynchronous APIs work.
The feeder module is the unsung hero. Apify returns engagement data as a single dataset. The feeder splits it into individual records that Airtable can process one at a time. Without the feeder, you get one massive record with every engager crammed into a single field. With it, you get a clean, queryable database where every engager is a separate row. This one module is the difference between a data dump and a CRM.
Enrichment is the compounding engine. Most people stop at collecting engagement data. They see 47 people liked their post and think that is the end of the analysis. But 47 names with no context is worthless. The enrichment pipeline fills in the context — who these people are, where they work, what they do, whether they are in your ICP. One post with 50 engaged profiles becomes 50 enriched contacts in your CRM. Ten posts becomes 500. A year of posting becomes thousands of structured, scored leads, all captured without a single manual data entry.
The Compounding Flywheel
Post → Engagement → Collection → Enrichment → CRM → Prioritized Outreach → Better Content → More Engagement
The Real Numbers
This is not theoretical. Here is what the system produces:
- Every LinkedIn post triggers engagement collection within minutes of publishing
- Each engager gets enriched with 10+ structured profile fields
- High-value contacts route to the CRM with ICP scores attached
- Enrichment data feeds back into content strategy — if VPs of Sales are engaging with pipeline content, I write more about pipelines
- Engagement history accumulates over time, so I can see who has been following my content for weeks versus who just showed up
The data does not just sit there. It powers every downstream decision: what content to write next, who to reach out to, which accounts to prioritize, what messaging to use. The engagement data from three months ago is still working for me today because it built a profile on contacts who are now in-market.
Building Your Own
If you want to build this yourself, start with the collection pipeline first. Get engagement data flowing into a database before you worry about enrichment. The enrichment layer adds value to data you already have. Without the collection layer, you have nothing to enrich.
Use Make.com or a similar orchestration tool. The specific modules matter less than the pattern: trigger, actor, sleep, fetch, split, store. Master that pattern and you can apply it to any data source, not just LinkedIn.
Most marketers are still manually visiting LinkedIn profiles and copy-pasting data into spreadsheets. You do not have to be one of them. The blueprint is here. The question is whether you will actually build it.
