# AppSignal vs PostHog: A Hands-On Error Tracking Comparison for 2026

One route in my bookstore app fires a recommendations call that rejects a promise and never handles it. Neither AppSignal nor PostHog filed it as an error. AppSignal counted the request as a success, and PostHog never heard about it. Two tools that came to error tracking from opposite directions shared one blind spot on day one, then disagreed about nearly everything after it.

AppSignal came from the server side. **AppSignal started as a performance monitor and treats errors as one signal among several,** next to traces, slow-query rankings, logs, host metrics and heartbeat monitors, all billed by request count.

PostHog came from the product side, with analytics first and engineering tools added over time. **PostHog started as product analytics and added error tracking as another product,** so an exception can open a session recording, a server trace and its logs, each metered past a free monthly allowance.

[ad-logs]

Both watched the same broken bookstore, browser and API, through three releases, so every section below is head to head. Where I skipped something, such as AppSignal's MCP server, the section says so.

## AppSignal vs PostHog: Results at a glance

The verdicts below rest on a single Express API and a single Vite storefront, each wired up the way the vendor's docs describe. Another language, or an afternoon spent on grouping rules, might shift a couple of these calls, grouping most of all.

| Area | Better in my test | Why |
|---|---|---|
| Setup | **AppSignal**, narrowly | Fewer switches, though its wizard skips ES modules |
| Error capture | Tie | Both missed the unhandled rejection and caught the rest |
| Debugging a server error | **PostHog** | Source lines and a full trace on the error page |
| Browser errors | **PostHog** | A replay of the crash next to the stack |
| Source maps | **AppSignal** | Mapped cleanly; PostHog's upload split old issues from new |
| Error grouping | **AppSignal** | The payment bug stayed one issue; PostHog made two |
| Releases and regressions | **AppSignal**, narrowly | Revisions become deploys on their own, with a per-release filter |
| The slow release | Tie | Both pinned the slowdown to 1.2.0 in a few clicks |
| Logs | **PostHog** | Logs open from a trace and query with SQL |
| Hosts, cron and metrics | **AppSignal** | PostHog has no host, uptime or cron monitoring |
| AI-assisted debugging | **PostHog**, with caveats | Its assistant explained the bug and also invented code |
| Price | **PostHog** for small apps | A far larger free tier; AppSignal's flat plan suits steady traffic |

## How I tested AppSignal and PostHog

monitoring-lab is a small bookstore app I keep for breaking on purpose. Its Express API keeps books in SQLite and depends on a fake price service I can make fail on demand, a report job runs every minute, and a Vite storefront handles navigation with hash routes. Every vendor gets a browser adapter and a server adapter of its own, so the failures are the same for each tool.

What fails:

- **In the browser:** adding to the wishlist dereferences `null`, the order tracker's promise rejects with nothing to catch it, and API calls fail with 404, 500 or 502.
- **On the server:** a made-up coupon crashes checkout, an unknown book ID crashes the book page, sold-out stock is sent as a handled error, and the price service returns 503.
- **In the background:** a recommendations promise rejects with no handler, and the minute-by-minute report job fails on some runs.

Three scripted shoppers make the traffic. alice and bob browse in headless Chromium, and carol skips the storefront and talks to the API.

### The releases

| Version | What it checks |
|---|---|
| 1.0.0 | Setup, first errors, source maps and debugging |
| 1.1.0 | A bug I closed comes back unchanged |
| 1.2.0 | Checkout's book query takes seconds, and every fifth card charge fails |

So 1.2.0 damages one request twice, and just one of the two failures raises an error.

### SDKs and coverage

| Platform | AppSignal | PostHog |
|---|---|---|
| API | `@appsignal/nodejs` 3.9.4 | `posthog-node` 5.57.2, OpenTelemetry for traces and logs |
| Storefront | `@appsignal/browser` 1.0.0-beta.9 | `posthog-js` 1.441.0 |
| Plan | 30-day trial | Free plan |

- **AppSignal's browser SDK is a beta,** listed under Labs.
- **Hosts:** AppSignal also ran on an Ubuntu server for the host and heartbeat checks, since its agent only collects host metrics on Linux.
- **Not tested:** AppSignal's uptime checks, alert delivery in either tool, and AppSignal's MCP server.

### Terms in each tool

| Idea | AppSignal | PostHog |
|---|---|---|
| Grouped errors | Error incident | Issue |
| One occurrence | Sample | Exception event |
| States | Open, Work in progress, Closed | Active, Resolved, Suppressed |
| Release | Revision, recorded as a deploy | `$app_version`, or a release from source map uploads |
| Request timing | Performance actions and samples | Tracing operations and spans |

## Setup and onboarding

Neither tool got from signup to clean data without help, and the help each needed was very different.

### AppSignal: A short wizard that assumes CommonJS

AppSignal's language picker sets expectations straight away:

![AppSignal language picker labelling Node.js as Full APM](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/e4019e83-a8b8-49b8-3575-72ca38a13800/lg2x =1512x802)

Node.js gets "Full APM" and plain JavaScript gets "Errors only", so you know the browser side is the smaller half. The steps were a package, a framework pick, an Express error handler, the key and a config file:

```javascript
[label src/monitoring/appsignal.js]
client = new Appsignal({
  active: true,
  name: 'monitoring-lab',
  pushApiKey: process.env.APPSIGNAL_PUSH_API_KEY,
  environment: config.environment,
[highlight]
  revision: config.appVersion,
[/highlight]
});
```

AppSignal's instructions launch Node through `--require`, a CommonJS-only flag, and monitoring-lab is written as ES modules, so I registered the module hook myself before Express would show up in traces. My first run reported "No data received" because of a stale key in my own `.env`, and the failure page pointed me to `appsignal.log` and a diagnose command. After the fix, data arrived within about a minute.

### PostHog: Many products, several switches

PostHog asks what you want to do first. I picked "Find and fix issues":

![PostHog onboarding with Product Analytics, Session Replay and Web Analytics preselected](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/3af3c7fe-7e5e-4e92-c4f5-5e4e0de6b600/lg2x =1512x803)

That goal ticked analytics, replay and web analytics, and left Error Tracking to add by hand. The Node.js page then flagged the step that matters for Express: register `setupExpressErrorHandler`, because Express catches errors before the SDK can.

The browser took more. posthog-js ignores headless browsers by default, so my scripted shoppers sent nothing until I changed one option:

```javascript
[label web/src/monitoring/adapters/posthog-browser.js]
posthog.init(import.meta.env.VITE_POSTHOG_TOKEN, {
  api_host: 'https://us.i.posthog.com',
  capture_exceptions: true,
  [highlight]opt_out_useragent_filter: true,[/highlight]
});
```

Session replay was the last surprise. I'd chosen it during onboarding, yet the project setting was still off:

![PostHog project settings with session replay switched off](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/a76164f4-ead1-47fc-a230-5befbbc32600/md1x =1512x803)

Until I flipped it, every error said replay wasn't active. My installed `posthog-node` was also too old for the Express request context helper, and updating it fixed that.

> **Worth turning on:** in AppSignal, register the ES module hook yourself if your app uses `import`, or Express won't be traced. In PostHog, add Error Tracking to the project, switch on session recording in project settings, and set `opt_out_useragent_filter` if you test with headless browsers.

### Setup comparison

| Step | AppSignal | PostHog |
|---|---|---|
| Error tracking on by default | ✔: yes | ✘: added by hand |
| ES module apps | ✘: hook registered by hand | ✔: no extra step |
| Express error handler | ✔: in the wizard | ✔: flagged on the setup page |
| Headless traffic | ✔: accepted | ✘: filtered until an option is set |
| Replay ready after onboarding | Not offered | ✘: off in project settings |
| Help when nothing arrives | ✔: log file and diagnose command | Not needed |

**Verdict: AppSignal, narrowly.** Its one trap only hits ES module apps. PostHog needed three switches before errors, browser traffic and replays all flowed.

## Error capture

Both got every planted failure but one, and it was the same one.

### AppSignal: 11 errors, the rejection in Logging

After the first run, AppSignal's list held 11 errors:

![AppSignal errors list grouped by class and route](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/391e5dd7-7b4f-4542-0595-6df4ffbd3900/lg1x =1512x802)

Each row is an error class on a route, split into `web` and `browser` namespaces. The browser SDK also files failed fetches as `HTTPError` rows next to my app's own `ApiError`, so a single failed call can count twice.

The missing rejection turned up elsewhere. The recommendations route showed 7 requests with no errors, and the failure only appeared because my app logs it:

![AppSignal log detail for the unhandled rejection](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/c68188d0-1800-416d-5459-107378472700/lg2x =1512x802)

The log entry carries the error text and revision 1.0.0. Without that log call, AppSignal would have shown nothing.

### PostHog: Every failure but one, with sessions and users

PostHog's issues list puts status, severity and assignee on every row:

![PostHog issues list with volume, occurrences, sessions and users](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/9f022921-f8c8-435c-aaf3-ab2ea79ba900/lg1x =1512x803)

Columns count occurrences, sessions and users for each issue. Anonymous requests get a fresh ID each time, so the price service failure showed 24 users for 24 events.

The rejection never arrived. posthog-node leaves unhandled rejections to Node, which only turns them into crashes when the app has no handler of its own, and mine has one. The report job's issue was named after my adapter's span wrapper, because PostHog picked that as the app frame.

### Capture comparison

| Test | AppSignal | PostHog |
|---|---|---|
| Wishlist crash in the browser | ✔: received | ✔: received |
| Server crashes | ✔: received | ✔: received |
| Sold-out handled error | ✔: received | ✔: received |
| Unhandled rejection | ✘: logged only | ✘: not received |
| Report job | ✔: received | ✔: named after the adapter |
| Failed fetches | Counted twice | Counted once |

**Verdict: Tie.** Each caught everything except the same rejection. Add your own handler that reports it, whichever you pick.

## Debugging a server error

How each tool presents the coupon crash says a lot about its origins.

### AppSignal: The request body, but no code

AppSignal's coupon error shows what the request carried:

![AppSignal request payload and deploy box on the coupon error](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/e3be2ddf-f0b0-4b15-a5b4-02b277f40100/lg2x =1512x802)

The JSON body shows the bad `FREEBOOKS` code, and a box names the deploy where the error first appeared. User identity comes through as tags, and my breadcrumbs sat in custom data as raw JSON, because the Node SDK has no breadcrumbs API.

The stack was harder going. The Summary tab showed only a Node internals frame, and the full backtrace flagged my own file:

![AppSignal backtrace with the ESM parse warning](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/ca3d0cc7-7caa-4b6f-fb6f-dad3e5600a00/md1x =1512x802)

The warning icon says AppSignal couldn't parse the `file://` line number that ES modules produce, so no code appears. Framework and AppSignal frames fill the rest, with no way to hide them on backend errors.

### PostHog: The code, the trace and its logs

PostHog read the source from disk and highlighted the failing line:

![PostHog coupon error with server source lines highlighted](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/f0bca47b-8c6d-4e0b-173c-6d26b3b1cf00/md2x =1512x803)

Lines 143 to 157 surround line 150, comment included, and Node internals fold behind "Show 1 vendor frame". The request body isn't there. "View trace" fills that gap:

![PostHog trace for the failing checkout request](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/3912d039-0b61-44d4-58c4-a56ed9a14700/md1x =1512x803)

All 8 spans of the failed checkout are there, my book query among them, with the user chip and a Logs tab for the request.

### Server debugging comparison

| Capability | AppSignal | PostHog |
|---|---|---|
| Source lines | ✘: parse warning on ES modules | ✔: read from disk |
| Request body | ✔: payload tab | ✘: not shown |
| Trace on the error | Root span only | ✔: all spans |
| Logs for the request | ✘: needs trace-linked logs | ✔: Logs tab on the trace |
| Breadcrumbs | Custom data as JSON | Through the trace and session |

**Verdict: PostHog.** It showed the failing line and every step of the request around it. AppSignal's payload view is handy, but on an ES module app you won't see your own code.

## Browser errors

The wishlist crash shows how each tool tells you what the shopper did first.

### AppSignal: Automatic breadcrumbs

AppSignal's browser SDK records network calls, clicks and navigation on its own:

![AppSignal browser breadcrumbs ending in the click and the crash](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/9cba6d82-975f-4c93-0961-aeb751111200/md2x =1512x802)

Each fetch has its status and duration, and the click names the button and its position. My own app breadcrumbs sit in the same list, ending at the error.

### PostHog: A timeline and a recording

PostHog's Recording tab plays the session at the moment of the crash:

![PostHog Recording tab at the moment of the wishlist error](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/022ed6f3-7c8c-4128-0f61-8010cd893b00/lg1x =1512x803)

The cursor rests on "Add to wishlist" for alice's session, with a link out to the full replay. At the Normal privacy setting only inputs were masked, so page text and the signed-in email were visible. The Timeline tab lists the same session's pageviews, exceptions, events and logs.

| Capability | AppSignal | PostHog |
|---|---|---|
| Clicks and network calls | ✔: automatic | ✔: in the timeline |
| Session replay | ✘: not offered | ✔: on the error page |
| Browser trace linked to the server | ✘: not seen | ✘: linked by session only |
| Default masking | Not applicable | Inputs only |

**Verdict: PostHog.** Watching the crash beats reading about it. AppSignal's breadcrumbs are the better record if you can't ship a replay script.

## Source maps

The storefront lived on a host neither vendor could reach, so I pushed the maps to both.

### AppSignal: One API call per revision

AppSignal accepts each map through an API endpoint, keyed to a revision:

```command
curl -X POST \
  -F "name[]=http://localhost:5173/assets/index.js" \
  [highlight]-F "revision=1.2.0"[/highlight] \
  -F "file=@web/dist/assets/index.js.map" \
  "https://appsignal.com/api/sourcemaps?push_api_key=$APPSIGNAL_PUSH_API_KEY&app_name=monitoring-lab&environment=development"
```

After that, the wishlist error resolved to my own source:

![AppSignal browser error mapped to src/pages.js](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/5fe680f1-07c2-4ff6-bd4e-50125d063800/orig =1512x802)

`src/pages.js` line 122 sits highlighted in its surrounding code, and the same issue kept counting.

### PostHog: Mapped, and split in two

PostHog's CLI injects an ID into each bundle and then uploads. The release name has to go on the inject step, or PostHog names the release after your git commit:

```command
posthog-cli sourcemap inject --directory web/dist \
  [highlight]--release-name monitoring-lab --release-version 1.2.0[/highlight]
posthog-cli sourcemap upload --directory web/dist
```

The docs show those flags on upload only, which is how my first release ended up named after a commit SHA. Mapping itself worked, with line 122 highlighted, but the wishlist crash now had two rows:

![PostHog wishlist crash as a minified and a mapped issue](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/b84ac144-6f76-464e-720f-6df1e08d9d00/lg1x =1512x803)

PostHog fingerprints the resolved frames, so events before and after the upload stopped matching. Upload maps before your first deploy, or merge the pair by hand.

| Capability | AppSignal | PostHog |
|---|---|---|
| Upload method | API call per file | CLI inject and upload |
| Release tag | Revision field | Set at inject, defaults to the git commit |
| Old issues after upload | ✔: kept counting | ✘: new issue created |
| Mapped code shown | ✔: yes | ✔: yes |

**Verdict: AppSignal.** The upload was one call and the issue stayed whole. PostHog mapped just as well, but its release naming and the duplicate issue need care.

## Error grouping

1.2.0's payment error carried the charge amount in its message, and the slow query changed the async path under several older errors.

### AppSignal: Class and route

AppSignal groups by error class plus the action it happened in:

![AppSignal payment gateway error as a single issue](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/7fefede7-42bd-4010-5fbe-974abe97e000/orig =1512x802)

Every charge, whatever the amount, landed in one issue on POST /checkout. Older bugs kept growing in their original rows through all three releases, and browser `ApiError` rows split cleanly by route.

### PostHog: Stack frames, Node internals included

PostHog ignores message text, which should have helped. It counted Node's internal frames though, and the payment bug became two issues:

![PostHog payment issue including vendor frames](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/5618ec75-ff4f-4559-2f63-48b20d181900/orig =1512x747)

Both issues share the same app frames. One also has two `node:internal` timer frames, hidden behind "Show 2 vendor frames" but still part of the fingerprint. The slow query caused it, because the extra wait changed which internals sat under the throw.

The same shift split the 1.1.0 coupon bug into three rows of 64, 6 and 3 events, and the sold-out error gained two siblings. Grouping rules can fix it, and PostHog ships with none set.

### Grouping comparison

| Test | AppSignal | PostHog |
|---|---|---|
| Grouping key | Class and action | Stack frames, internals included |
| Payment error in 1.2.0 | ✔: 1 issue | ✘: 2 issues |
| Coupon bug in 1.2.0 | ✔: same issue | ✘: 3 issues |
| Values in the message | ✔: ignored | ✔: ignored |
| Fix tools | Not needed here | Grouping rules or manual merge |

**Verdict: AppSignal.** Its rows held through a code change that split PostHog's. A Node backend on PostHog needs a grouping rule before the first slow release, or "new issue" alerts will fire for bugs you already know. Our [PostHog vs Rollbar comparison](https://betterstack.com/community/comparisons/posthog-vs-rollbar/) shows the same Node frames splitting another tracker.

[summary]
<iframe width="100%" class="aspect-video h-auto" src="https://www.youtube.com/embed/-26mmryojE4" title="Error tracking | Better Stack" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

AppSignal kept the payment bug whole but hid my code, and PostHog showed the code but split the bug. Better Stack, fed by the same app, did both on one page:

![Better Stack payment error as one group with its source](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/e5e5a3b3-9db0-4323-aa84-fa0088103900/lg2x =1512x744)

Ten exceptions with ten different amounts share the group, and the throwing code sits beneath them. No grouping rule was needed.

**[Stop one bug from splitting](https://betterstack.com/error-tracking)**
[/summary]

## Releases and regressions

On 1.0.0 I marked the coupon error as done in each tool, then released 1.1.0 with the faulty code untouched.

### AppSignal: Reopened, and filtered by revision

AppSignal's State menu warns that any triggered notification reopens a closed error. On 1.1.0 it did:

![AppSignal coupon error reopened on 1.1.0](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/65a09150-d48e-4061-9ebf-0313b52dde00/orig =1512x802)

State reads Open and the newest sample carries revision 1.1.0. The header keeps reporting 1.0.0 as the first occurrence, nothing calls it a regression, and the Logbook lists my close but not the reopen.

Its list filter does the work a label would. "Most recent revisions" is the default, and it splits each row into counts for the newest release and all time:

![AppSignal errors list filtered to the most recent revision](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/0ef94b09-006a-4756-3354-4ddeb1502700/orig =1512x802)

Eight errors appeared on 1.1.0, the coupon bug at 5 of 30. Setting the revision in config was enough to record each deploy, with errors per hour on the Deploys page.

### PostHog: Reopened, and broken down by version

PostHog's Resolve offers no version option. Clicking it brought up something no other tracker has shown me:

![PostHog toast offering to tell affected users the bug is fixed](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/cbef3f3e-4a4f-41a3-597b-bfc999fc2e00/public =1512x747)

Two signed-in shoppers had hit the bug, and the toast offers to email them, which I skipped. Traffic on the new build flipped the issue to Active again, adding 20 events, again with no regressed label, and the Breakdown panel showed where they came from:

![PostHog Breakdown panel splitting the issue by app version](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/06caeb1c-f5b8-47b0-4528-66252ee15500/lg1x =1512x747)

The bars read 44 events for 1.0.0 and 20 for 1.1.0, keyed on `app_version`. Its Releases panel, by contrast, showed nothing until I switched my adapters to the `$app_version` property PostHog expects.

### Release comparison

| Capability | AppSignal | PostHog |
|---|---|---|
| Resolve for a future version | ✘: not offered | ✘: not offered |
| Returning bug reopened | ✔: yes | ✔: yes |
| Reopen labelled | ✘: no | ✘: no |
| Reopen in the history | ✘: missing | Not checked |
| Releases recorded | ✔: from the revision setting | Needs `$app_version` or source map uploads |
| Per-release view | ✔: revision filter on the list | ✔: breakdown on each issue |
| Notify affected users | ✘: not offered | ✔: email offer on resolve |

**Verdict: AppSignal, narrowly.** It recorded every release from one config value and filtered the whole list to the newest. PostHog's version breakdown and user emails are good ideas that sit on a release setup needing more care.

[summary]
<iframe width="100%" class="aspect-video h-auto" src="https://www.youtube.com/embed/E8JQPRVR20E" title="On-call overview | Better Stack" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

AppSignal and PostHog both reopened the coupon bug and then left it looking like every other open error. Better Stack flagged it in the list:

![Better Stack list with the coupon bug marked Reoccurred](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/ff9ed40b-81f9-4dea-bca1-9d2fdeccd200/lg1x =1512x744)

Only the coupon row turned red as "Reoccurred" once 1.1.0 events arrived, read from the SDK's release value. You see the failed fix without opening anything.

**[Spot a failed fix at a glance](https://betterstack.com/error-tracking)**
[/summary]

## The slow release

1.2.0 slowed checkout's book query to seconds and threw nothing for it. Both tools saw it, from different pages.

### AppSignal: A mean for every deploy

AppSignal's checkout action lists performance for each recent deploy:

![AppSignal performance per deploy for checkout](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/ad71c436-657c-4494-63b8-dff9a771b400/lg2x =1512x802)

Checkout averaged 2 ms on both earlier releases and 4.59 s on 1.2.0. A slow 1.2.0 sample split that time into the 3.06 s book query, a 3.3 s card charge marked as errored and retried, and the order insert. The Slow queries page moved the book query to the top, at 67.6% of query time.

The failing requests were harder to read. A checkout that ended in the payment error kept only its root span:

![AppSignal trace for a failed checkout showing only the root span](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/072884f4-ac02-439c-d6a6-c546c3ce2400/md2x =1512x802)

3.34 s shows as "Other", with no query or charge to explain it. My Slow actions trigger, set at a 1 s mean for the whole web namespace, didn't fire either, because fast pages kept the average low.

### PostHog: p95 by operation and version

PostHog's Tracing Operations view ranks every span name by percentile:

![PostHog Operations with all versions and p95 per operation](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/f680cf41-25a5-4403-e985-6b946f982200/md2x =1512x747)

Checkout's p95 reached 4.76 s with a 22.3% error rate, and the book query's p95 hit 2.93 s. Filtering to version 1.1.0 confirmed the release:

![PostHog Operations filtered to version 1.1.0](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/5d04e70b-f39e-4361-0873-09d41c951600/md1x =1512x747)

The previous release had held checkout's p95 at 4.21 ms. PostHog reads that version from the OpenTelemetry resource attributes without any setup, and failed requests kept their child spans.

| Capability | AppSignal | PostHog |
|---|---|---|
| Slowdown per release | ✔: mean per deploy | ✔: p95 with a version filter |
| Slow query ranking | ✔: Slow queries page | ✔: sort operations by p95 |
| Spans on failed requests | ✘: root span only | ✔: kept |
| Alert on the slowdown | ✘: trigger didn't fire | Not set up |

**Verdict: Tie.** Each pointed to the book query on 1.2.0 within a couple of clicks. PostHog keeps the spans on failed requests, and AppSignal ranks your queries without being asked.

[summary]
<iframe width="100%" class="aspect-video h-auto" src="https://www.youtube.com/embed/7tQ7haFmSXI" title="Explore Traces | Better Stack" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

AppSignal lost the spans on the checkout that failed, and PostHog measured the slowdown across many requests. Better Stack showed both causes on one failing 1.2.0 checkout:

![Better Stack spans for the slow 1.2.0 checkout](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/65353da5-9fc2-4deb-6b1a-26ad95621f00/lg1x =1512x744)

That 2.19 s checkout spent 1.53 s waiting on the book lookup and another 660 ms on a charge the gateway refused. The broken request carries its own explanation.

**[Trace the request that failed](https://betterstack.com/tracing)**
[/summary]

## Logs

Both store logs, but only one ties them to the request that wrote them.

### AppSignal: Logging with live tail

AppSignal's logger sent lines with severity and host, ready for live tailing:

![AppSignal logs viewer](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/c0ef2347-8fbe-48e0-bdd0-ef646a5a6100/md2x =1512x802)

Each line offers "Show in context", a link and "Create a metric". Error pages said "No related log lines found" until trace-linked logs were set up, so logs and errors stayed apart in my test.

### PostHog: Logs inside the trace

PostHog took my logs over OpenTelemetry, with Patterns, Group, Live tail and a SQL tab. The useful part sits on each trace:

![PostHog trace span panel with its Logs tab](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/620905a8-24ee-4028-af0c-00b3c370a100/orig =1512x803)

The span panel's Logs tab holds that request's lines and nobody else's. From an error, it's two clicks to what the request wrote.

| Capability | AppSignal | PostHog |
|---|---|---|
| Live tail | ✔: yes | ✔: yes |
| Logs from an error | ✘: not linked in my setup | ✔: through the trace |
| Query language | Filters | ✔: SQL |
| Metric from a log line | ✔: Create a metric | ✘: not seen |
| Free log volume | 1 GB | 10 GB a month |

**Verdict: PostHog.** Its logs open from the failing request and query with SQL. AppSignal's are a good stream that I couldn't reach from an error.

[summary]
<iframe width="100%" class="aspect-video h-auto" src="https://www.youtube.com/embed/XJv7ON314k4" title="Live tail overview | Better Stack" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

AppSignal's logs never reached an error page, and PostHog's sat one trace away. Better Stack's Live tail filtered straight to the failing 1.2.0 checkout:

![Better Stack Live tail filtered to one failing checkout](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/0bd2859e-1627-424b-5fcb-b7bb7027c200/public =1512x744)

The slow-query warning appears beside the failure, and no other shopper's lines get in the way. Each line stays searchable afterwards.

**[Search logs by the request that broke](https://betterstack.com/log-management)**
[/summary]

## Hosts, cron jobs and metrics

This section is mostly AppSignal's, because PostHog doesn't monitor servers, uptime or scheduled jobs.

### AppSignal: Hosts and heartbeats on a real server

On my Ubuntu server, host metrics arrived with no extra setup:

![AppSignal host metrics list](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/41bd94a5-8509-4fae-58c3-a37638fd2a00/orig =1512x802)

Load, memory and disk sit next to each host, and the detail pages chart CPU, swap, disk I/O and network with deploy markers. For process monitoring, `appsignal-run` wraps the start command and sends heartbeats:

![AppSignal heartbeat monitor marked Missed](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/25a904cf-4d27-4ebc-5e4b-62ec6a71b300/md2x =1512x802)

Stopping the app turned the monitor red within a couple of minutes. One catch: heartbeats are ignored until you create a monitor with a matching name, and the CLI never mentions it. Custom metrics need a dashboard chart before they show anywhere, roughly ten clicks each.

### PostHog: Metrics in alpha

PostHog's Metrics product needed a feature preview switched on, and its Overview tab failed to load. The Viewer worked, with Builder, PromQL and SQL modes and a "Create alert" button on my revenue histogram.

| Capability | AppSignal | PostHog |
|---|---|---|
| Server metrics | ✔: collected on Linux with no config | ✘: not offered |
| Heartbeat and cron monitors | ✔: tested, turned red on stop | ✘: not offered |
| Uptime checks | Bundled, untested | ✘: not offered |
| Custom metrics | ✔: through dashboards | Alpha, PromQL and SQL |
| Anomaly alerts | Per namespace, didn't fire | Alerts on issues and metrics, not set up |

**Verdict: AppSignal.** It watches the server and the jobs as well as the code. With PostHog you'd add a separate tool for uptime and cron.

## AI-assisted debugging

Only one of these has an assistant inside the app.

### PostHog: An assistant that explains, and guesses

Every PostHog issue can build a prompt and open it in PostHog AI, Claude Code, Cursor, Codex or your clipboard. Asked about the coupon crash, PostHog AI got the cause right:

![PostHog AI explaining the coupon error](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/be529844-931d-4705-413f-fc58d378b300/lg1x =1512x747)

It saw that the code checks for a coupon but not a valid one, and suggested optional chaining and a 400 response. Then it wrote out what my coupon table "likely" held:

![PostHog AI guessing the contents of the coupon table](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/cfe0366a-2dab-473c-4d6c-11d8172d1a00/lg2x =1512x747)

None of those codes exist in my app. For the payment bug, it said the charge amount in the message caused the two issues, though each issue mixed several amounts, and it made up a retry loop that it called a reconstruction. It never connected the errors to 1.2.0.

### AppSignal: An MCP server, untested

Nothing in AppSignal's interface offered AI help while I tested. Its docs list a beta MCP server that lets coding assistants read incidents, traces and metrics, which I didn't try.

| Capability | AppSignal | PostHog |
|---|---|---|
| Assistant in the product | ✘: not offered | ✔: PostHog AI |
| Hand-off to coding tools | Beta MCP server, not tested | ✔: prompt for Claude Code, Cursor and others |
| Accuracy in my test | Not tested | Right on the mechanism, invented details |

**Verdict: PostHog, with caveats.** It was the only one I could test, and it got the coupon bug's cause right. Check anything it says about code it hasn't seen.

[summary]
<iframe width="100%" class="aspect-video h-auto" src="https://www.youtube.com/embed/n6TtDk8ITgc" title="AI SRE demo | Better Stack" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

PostHog AI filled gaps with guesses, and AppSignal leaves AI to tools you connect yourself. Better Stack's AI SRE looked at release 1.2.0 with no repository connected:

![Better Stack AI SRE comparing release 1.2.0 with 1.1.0](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/156c28b3-08a9-4423-a025-fac33aa2c700/public =1512x744)

It measured the book query climbing from 0.13 ms to 2.6 s while other statements held near 0.1 ms, then matched all 10 declined charges in a sample of 48 to the new build. Both causes were right, for about $0.49 of usage.

**[Let AI SRE review your next release](https://betterstack.com/ai-sre)**
[/summary]

## Pricing

AppSignal's plans are priced by monthly request volume, with every feature included and no overage bills. PostHog bills each product separately once its monthly free allowance runs out.

My pricing figures come from AppSignal's page on November 4, 2026 and PostHog's on November 12. PostHog's per-exception rate is from my October 28 reading. Check both before you commit.

### Free plans and trials

| Plan detail | AppSignal Free | PostHog Free |
|---|---|---|
| Volume | 30,000 requests a month | 100,000 exceptions a month |
| Logs | 1 GB | 10 GB a month |
| Retention | 5 days | 1 year of events |
| Session replay | ✘: not offered | 5,000 recordings a month |
| Host, uptime and cron | Included | ✘: not offered |
| Paid-plan trial | 30 days, no card | Not needed |

PostHog shows its free allowances during onboarding:

![PostHog plan step comparing Free and Pay-as-you-go](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/1521b9d1-99b6-4972-eb3f-e48280ea7800/public =1512x747)

Both plans share the same monthly free amounts. Pay-as-you-go adds projects and lifts the caps.

### Entry-level paid plans

| First paid tier | AppSignal entry plan | PostHog Pay-as-you-go |
|---|---|---|
| Base price | $279 a year, about $23.25 a month | $0 |
| Volume | 250,000 requests a month | 100,000 exceptions free, then $0.000370 each |
| Logs | 1 GB a month | 10 GB free, then usage based |
| Tracing | ✔: included | Usage based |
| Over the limit | Moved up a tier after a 30-day review | Billed per unit, with caps you set |

### Comparing the actual cost

On the free tiers, PostHog is far ahead: 100,000 exceptions, 10 GB of logs and 5,000 replays, against AppSignal's 30,000 requests and five days of history.

Paid, the units pull apart. AppSignal counts requests, so a busy API pays for every healthy call, and the bill doesn't move with the error rate. PostHog counts exceptions, log gigabytes and recordings separately, so a quiet app stays free and a bad release that throws thousands of errors shows up on the invoice. Set spending caps on each product. Our [Sentry vs AppSignal comparison](https://betterstack.com/community/comparisons/sentry-vs-appsignal/) weighs AppSignal's flat plan against another usage-based bill.

**Verdict: PostHog for small apps.** Its free tier covers more than AppSignal's paid entry plan in errors and logs. AppSignal is the steadier bill for a high-traffic app that wants hosts and cron in one place.

## Full feature comparison

| Feature | AppSignal | PostHog |
|---|---|---|
| Error tracking on by default | ✔: yes | ✘: added in onboarding |
| ES module Node apps | Manual hook, no code on frames | ✔: source lines |
| Unhandled rejection | ✘: logged only | ✘: not received |
| Request body on errors | ✔: yes | ✘: no |
| Full trace on a failed request | ✘: root span only | ✔: yes |
| Session replay | ✘: not offered | ✔: on the error page |
| Source maps | ✔: API per revision | ✔: CLI, release set at inject |
| Payment error in 1.2.0 | ✔: 1 issue | ✘: 2 issues |
| Returning bug reopened | ✔: yes | ✔: yes |
| Releases recorded | ✔: from config | Needs `$app_version` or uploads |
| Slowdown per release | ✔: mean per deploy | ✔: p95 by version |
| Logs linked to errors | ✘: not in my setup | ✔: through the trace |
| Host metrics | ✔: automatic on Linux | ✘: not offered |
| Cron and heartbeats | ✔: yes | ✘: not offered |
| Uptime checks | Included | ✘: not offered |
| AI | Beta MCP server | PostHog AI and coding-tool prompts |
| Free plan | 30,000 requests | 100,000 exceptions plus other products |

## Which should you choose?

The decision is about where your problems usually start: on the server or in front of the user.

### Choose AppSignal if your problems live on the server

- **You want errors that stay grouped.** Class-and-action grouping kept every server bug in its row through all three releases.
- **You ship often and want each release accounted for.** One revision setting gives you deploys, a per-release error filter and response times per deploy.
- **You also need to watch hosts and jobs.** Host metrics, heartbeats and uptime checks come in the same plan.

The cost: an ES module app needs a manual hook and shows no code on server frames, failed requests lose their spans, and the browser SDK is still a beta. Our [AppSignal vs Raygun comparison](https://betterstack.com/community/comparisons/appsignal-vs-raygun/) shows how it holds up against a tool with stronger browser monitoring.

### Choose PostHog if your problems show up in front of users

- **You want to see what the user saw.** Replays open from the error page, and its timeline holds the session's events and logs.
- **You want the code and the request in one place.** Server errors show source lines, and a trace with logs is one click away.
- **You're cost-sensitive at low volume.** The free tier covers errors, logs, tracing and replays for most small apps.

The cost: three switches before everything works, Node grouping that splits when timing changes, releases that need careful naming, and no uptime or server monitoring. Our [LogRocket vs PostHog comparison](https://betterstack.com/community/comparisons/logrocket-vs-posthog/) weighs its replay against a dedicated session tool.

## FAQ

### Did either tool catch unhandled promise rejections in Node.js?

Not in my test. AppSignal recorded the request as successful and kept the error only in Logging, and PostHog never received it because my app registers its own rejection handler. Report rejections yourself in either.

### Why does PostHog split one bug into several issues?

It fingerprints the stack, including Node's internal frames. A change in timing, like a slower query, can alter those frames and create a new issue. Grouping rules or a manual merge fix it.

### Does AppSignal have session replay?

No. Its browser SDK records clicks, network calls and navigation as breadcrumbs, and sends web vitals as metrics, but it doesn't record sessions.

### Which is cheaper?

PostHog for most small apps, with 100,000 free exceptions a month and replay included. AppSignal's entry plan costs about $23.25 a month on annual billing and suits steady traffic with no surprises.

## Final thoughts

AppSignal and PostHog missed the same failure and then split almost every other result between them. **AppSignal kept its error list tidy and watched the servers underneath, while PostHog showed the code, the trace and the user's own screen, then let a slower query break its grouping.**

So the choice comes down to where your bugs show up. If they surface as slow endpoints and noisy hosts, AppSignal fits that shape. If they arrive as support tickets that start with "I clicked the button and nothing happened", **PostHog's replay will answer the ticket before its grouping does.**
