Heap

Heap and PostHog get shortlisted against each other most often by Series A–B PLG teams choosing their first real analytics tool. They look adjacent — both ship events, funnels, retention, and session replay — but the wedges that decide the buy are autocapture vs deliberate instrumentation, and bundled LLM observability vs analytics-only depth.

Typical fit: who each tool is built for

Typical Heap customer

• Series A–B PLG SaaS launching a new product surface without an event taxonomy
• PM + CS teams that need retroactive funnel analysis the day a question lands, not next sprint
• Mid-market B2B with CS Ops reading session replays in QBR prep and pasting replay links into Zendesk tickets
• Teams already on Contentsquare for experience analytics who want the autocapture extension

Typical PostHog customer

• Indie + Series A SaaS under ~1M MAU running one product with a small eng team
• AI-native startups that need LLM token-cost tracking alongside product analytics on one invoice
• PLG teams shipping feature-flag rollouts where replay + flag variant live in the same UI
• Regulated or data-residency-bound orgs that need an open-source self-host path

Neither if you're…

• A Series C+ multi-product org with named analysts and a formal experimentation program — see Amplitude
• A CS + Product team that wants in-app guidance, feedback portal, and analytics under one governance umbrella — see Pendo
• An analytics-only buyer that wants polished reporting and warehouse-native mode — see Mixpanel

When Heap wins

Heap wins when the input to your workflow is autocaptured DOM and form data — every click, every page view, every form field — and the question is "what did users actually do last month?" rather than "what did we plan to track?". The AI step is Sense AI surfacing anomalies and trend changes on autocaptured streams; the human review is a PM or CSM converting interactions into named events after the fact. Writeback flows to Salesforce, HubSpot, or Iterable via cohort sync, plus Zendesk-pasted replay links. The metric that matters is time-from-question-to-first-cohort.

Concrete scenarios where Heap is the right call:

• A new pricing page ships Friday; CS needs the click pattern of accounts that bounced before Monday's QBR. Heap answers in an hour against historical clicks; PostHog needs the event instrumented first.
• A PM joins, inherits a product with thin instrumentation, and needs to map activation paths against the last 90 days. Heap's retroactive event definition gets there without a backfill sprint.
• A CS team uses session replay + click data side by side for adoption investigation — the autocapture-tied replay link is genuinely faster than tools where replay is a separate pipeline.

Heap loses momentum the moment downstream automation needs governed definitions. Three PMs defining "Signed up" three ways becomes Salesforce activity record noise within a quarter.

When PostHog wins

PostHog wins when the input is a deliberately instrumented event stream (SDK or Segment), the AI step is Max AI answering structured natural-language questions plus LLM observability tagging token cost and latency on every span, and the human review is an engineer or PM validating events and flag rollouts before production. Writeback flows to Customer.io, HubSpot, or Snowflake via reverse ETL; flag toggles ship in-app. The metric that matters is invoices-per-product-loop — PostHog's wedge is that one tool covers analytics, replay, flags, and LLM observability.

Concrete scenarios where PostHog is the right call:

• An AI-native startup needs token cost + latency tracking on every LLM call alongside product analytics. PostHog's LLM observability competes with LangSmith and Helicone on cost tracking; Heap doesn't ship this surface at all.
• A small eng team ships feature flags weekly and wants replay + flag variant in the same UI without context-switching between vendors.
• A regulated team needs self-host with Postgres + ClickHouse — PostHog ships an open-source path; Heap is closed cloud.

PostHog loses the moment a Series C team needs governed taxonomy, multi-product audience syncs with SLAs, or a formal experimentation program with analyst tooling.

When you need both

Rarely, but it happens. The pattern: PostHog as the deliberately-instrumented backbone for product analytics + flags + LLM observability, with Heap layered on a specific surface (often a new acquisition or a legacy product) where retroactive answers matter more than taxonomy hygiene. This is a transitional state — usually a 2–3 quarter coexistence before consolidating onto whichever side fits the longer-term governance posture. See the CSM health-score playbook for the cohort-to-CRM half of either loop.

Pricing and per-account math

Heap's pricing is opaque post-Contentsquare acquisition — free tier with session-volume limits, Growth and Pro custom per session volume, and packaging still reshaping through 2026. Confirm what's actually in your tier at procurement.

PostHog publishes pay-as-you-go pricing: $0.000248/event after the free tier (1M events + 5k replays/mo), with replay, feature flags, and LLM observability metered separately. The crossover math:

• Sub-1M MAU, ≤5M events/mo, modest replay sampling → PostHog usually wins on bundled cost.
• 10–20M MTUs with replay + LLM observability stacked on top → per-event math flips; Mixpanel or Amplitude start looking cheaper for analytics-only needs.
• Heap's mid-market contracts typically land between PostHog at scale and Amplitude Enterprise, but the lack of public list price means budgeting is a procurement exercise.

We do not invent dollar figures. Verify against vendor pricing pages above and your own usage projection.

Feature overlap and gaps

Both ship events, funnels, retention, behavioral cohorts, and session replay. The capability matrix:

The wedge is clear: Heap leads on autocapture and retroactive analysis; PostHog leads on bundled flags + LLM observability and pricing transparency.

The buying mistakes we see most

1. Picking Heap and skipping the taxonomy cleanup. Autocapture removes the day-one bottleneck and creates governance debt by month six. Three PMs define "Signed up" three ways; downstream cohorts and Salesforce syncs inherit the ambiguity. Cost: 1–2 weeks of RevOps cleanup per quarter, or worse, CS plays running on wrong cohorts. Mitigation: schedule a definition cleanup pass before any CRM writeback.
2. Picking PostHog and leaving autocapture on globally. $0.000248/event compounds quietly. A mobile SDK upgrade or marketing site instrumentation triples ingestion overnight. Cost: surprise renewal math. Mitigation: set ingestion filters and event allow-lists before traffic scales.
3. Buying either tool as a CDP substitute. Both ship cohort sync to Salesforce/HubSpot; neither replaces a dedicated reverse-ETL layer (Hightouch, Census) for multi-destination, governed audience syncs at scale. Cost: stalled sync jobs, half-synced audiences, broken CS playbooks.
4. Treating Sense or Max AI as autonomous analysts. Both surface anomalies and draft cohort definitions; neither owns event definitions or identity resolution. Confident-wrong cohorts ship to sales if a human doesn't validate. Sample AI-flagged cohorts for two weeks before automating.
5. Self-hosting PostHog without a dedicated infra owner. Postgres + ClickHouse + Kafka ops cost real platform-eng time. Cloud is usually cheaper on total cost unless data residency forces self-host.

What to test in week 1

Heap one-week test: Pick one PQL or expansion signal ("opened pricing page twice + viewed billing settings in 14 days"). Use autocapture to retroactively build the cohort from the last 30 days. Manually review 10 accounts against CRM records — does the click pattern reflect real interest or noise? Sync a test audience to Salesforce/HubSpot and route to one CSM. Measure: % cohort accounts where outreach landed vs "stale account" rejection, time-to-first-cohort vs your prior tool. If >30% noise, do not sync to CRM; fix definitions and identity resolution first.

PostHog one-week test: Pick one activation metric tied to revenue ("completed onboarding step 3 within 24h"). Instrument the event (or confirm autocapture caught it); write the definition in a shared doc. Build the funnel; sample 5 dropped users from replay; document what actually breaks. Ship one flag-controlled tweak (A/B). Measure: activation lift, total elapsed time vs prior stack, replay-watch time per CSM. If you can't complete all five steps in a week, the bottleneck is instrumentation hygiene, not the tool.

Migration and coexistence

Switching directions matter:

• Heap → PostHog: Plan a 90-day dual-run. Export the cohort definitions you actually use, re-instrument the underlying events deliberately in PostHog, and validate cohort overlap before cutting Heap. Identity resolution is the migration risk — Heap's anonymous → identified merge logic differs from PostHog's; expect a one-week audit.
• PostHog → Heap: Rarer. Usually triggered by a CS-led product team that wants retroactive analysis without instrumentation discipline. Export PostHog events to a warehouse first; Heap's autocapture will start fresh on click data, so historical PostHog event archives are your bridge.
• Coexistence: Some teams keep PostHog for flags + LLM obs and Heap for retroactive product analysis on a specific surface. This works for 2–3 quarters; pick a consolidation date in the contract.

Contract risk on Heap is the post-Contentsquare packaging drift — confirm feature parity and pricing at renewal. Contract risk on PostHog is the per-event meter at scale — model your 12-month event volume before signing an annual.

FAQ

Does Heap or PostHog work better with Salesforce and HubSpot? Both ship native cohort sync to Salesforce and HubSpot. Neither replaces a dedicated reverse-ETL layer for governed, multi-destination audience syncs. For enterprise CRM writeback with SLAs, pair either tool with Hightouch or Census. See HubSpot vs Salesforce for the CRM decision underneath.

Can PostHog's LLM observability replace LangSmith or Helicone? For cost and latency tracking, yes. For deep prompt versioning, evaluation suites, and trace-level debugging, LangSmith and Helicone still go further. Heap doesn't compete in this surface.

Is Heap still independent after the Contentsquare acquisition? Heap is a Contentsquare product as of 2024. Packaging and pricing are integrating through 2026. Confirm feature parity at procurement and renewal.

Which tool is cheaper at scale? Sub-1M MAU, PostHog typically wins on bundled cost. Past 10–20M MTUs with replay + LLM obs stacked on top, the per-event math flips and Heap mid-market contracts can land cheaper than PostHog on analytics-only volume — but Heap's opaque pricing makes this a procurement exercise, not a quick calc.

Does gtmpod earn commission on either tool? Yes on PostHog, no on Heap. We still route enterprise readers to Amplitude or Mixpanel when those fit better.