# Sentry vs BugSnag: An Error Monitoring comparison for 2026
Both Sentry and BugSnag detected all six bugs I planted in a Node.js application. Both kept the errors separate, showed useful breadcrumbs, and recognized when a supposedly fixed bug returned. So why choose one over the other?
The answer became clear when I released version 1.1.0 without fixing the checkout bug. **Sentry marked it as _Regressed_ in the issue list and on the release page. BugSnag reopened it too, but recorded the change inside the error's activity feed.** The same event was visible in both tools, yet much easier to spot in one.
[ad-logs]
That difference carries through the rest of the comparison. **Sentry connects error monitoring to traces, CPU profiles, structured logs and application metrics**. BugSnag concentrates on error triage and release stability, with a cleaner, narrower workflow. It also offers performance monitoring, but its Node.js integration requires separate OpenTelemetry instrumentation.
To see how those choices affect day-to-day debugging, I instrumented the same Express bookstore API with both tools and ran six deliberate failures and two slow paths on October 20–21, 2026. What follows is based on the screens and event data from that experiment. Where something was not configured or tested, I say so instead of calling it unsupported.
## Quick verdict: Sentry vs BugSnag
| What matters most | Better fit in this test | Why |
|---|---|---|
| Keeping distinct bugs apart | **Tie** | Both created 6 issues for 6 bugs |
| Reading an error without opening your editor | **Sentry** | Inline source lines; BugSnag showed frames only |
| Breadcrumbs and user context | **Tie** | Both have a searchable breadcrumb timeline and a user tab |
| Precise filtering | **Tie** | Both filter on user, release and more with structured syntax |
| Seeing a regression at a glance | **Sentry** | Regressed label in the list and a release tab |
| Release stability | **Tie** | Both track sessions per release automatically |
| Diagnosing slow requests with this setup | **Sentry** | Its configured tracing and profiling exposed the bottleneck; BugSnag performance was not instrumented |
| Keeping logs and application metrics in the same product | **Sentry** | Sentry offered both in this test; BugSnag focuses on errors and performance |
| Fewest concepts to learn | **BugSnag** | A narrower product with a calmer interface |
**Bottom line:** Choose **Sentry** if you want to move from an error to the slow function, related logs and release history without changing products. Choose **BugSnag** if error triage and application stability are the priorities, especially when your team already has separate tracing and logging tools.
## Feature comparison
| Area | Sentry | BugSnag |
|---|---|---|
| Signup in my test | ✔: no card for the 14-day Business trial | ✔: no payment step in onboarding, 14-day trial |
| The two tested TypeErrors | ✔: 2 separate issues | ✔: 2 separate errors |
| Source in stack trace | ✔: inline lines from local files | ✘: file, line and frames only |
| Handled vs unhandled | ✔: Unhandled label and mechanism | ✔: badge on every row |
| Breadcrumbs | ✔: timeline | ✔: timeline with search and type filter |
| Custom context | ✔: own panel | ✔: own DETAILS tab |
| Related events | ✔: linked logs and trace | ✔: correlated events by user and session |
| Search | ✔: typed field:value syntax | ✔: structured filters, such as userEmail |
| Resolve options | ✔: now, next release, release or commit | ✔: fixed until it occurs in a new version |
| Snooze or archive | ✔: five conditions | ✔: four conditions |
| Regression signal | ✔: Regressed label, list and release tab | ✘: activity entry only |
| Release stability | ✔: crash-free session rate | ✔: session stability |
| Server tracing | ✔: configured using Sentry SDK | ✔: available through separate OpenTelemetry setup, not tested here |
| Profiling | ✔: continuous profiling | ✘: not offered |
| Logs and metrics | ✔: both | ✘: neither |
| AI workflow tested | Not run: Seer requested a connected repo in my setup | Not run: Fix with MCP requested a SmartBear MCP connection |
## How I tested
The test app is a small bookstore API called monitoring-lab, built with Express on Node.js. I seeded it with six bugs and two slow paths, so both tools had the same things to find:
| Bug or slow path | What triggers it | Kind |
|---|---|---|
| Missing book | GET /books/:id with a bad ID reads `title` | Unhandled TypeError, line 38 |
| Bad coupon | POST /checkout with an unknown code reads `discount` | Unhandled TypeError, line 81 |
| Out of stock | Checkout when quantity exceeds stock | Handled, reported manually |
| Price service down | GET /prices/:id calls an upstream that returns 503 | UpstreamError |
| Broken promise | GET /broken-promise rejects with no catch | Unhandled rejection |
| Sales report job | A background job that fails every run | Handled job error |
| Slow search | GET /search does a CPU-heavy match | About 2 s per request |
| Slow prices | The upstream call to the price service | 1 to 3.5 s per request |
| Item | Sentry | BugSnag |
|---|---|---|
| SDK | @sentry/node 11.8.0 | @bugsnag/js with @bugsnag/plugin-express |
| Extra packages | @sentry/profiling-node | none |
| Release | monitoring-lab@1.0.0, then 1.1.0 | 1.0.0, then 1.1.0 |
| Deploy call | none, release set in the SDK | none, appVersion set in the SDK |
The test had two phases. First, I sent traffic to version 1.0.0, confirmed the issues appeared, and resolved only the bad-coupon error. Then I changed the version to 1.1.0 **without fixing the code**, restarted the app, and replayed the traffic. That second phase tested whether each tool would recognize a regression rather than treat the failure as a brand-new bug.
**A note on the numbers:** The traffic runs were separate, and the upstream delay was randomized. Counts and latency percentiles are evidence of what happened in each run, not a controlled benchmark of the vendors. In BugSnag's Express integration, a server request can count as a session, so its release-stability percentage should not be read as the proportion of unique users who experienced no crash. See the [BugSnag session tracking documentation](https://docs.bugsnag.com/platforms/javascript/capturing-sessions/).
## Getting started
### Signing up
Sentry started me on a Business Plan Trial with no card, and onboarding led with setup through a coding agent. The step that mattered was "Connect your code". I skipped it, which later blocked Seer and left my releases with 0 commits.
BugSnag's onboarding has four steps: Welcome, Create Project, Invite Collaborators and Integrate BugSnag. Its first question is where your application runs: Mobile, Browser, Server, Desktop, TV or Console. That ordering says a lot about the product. BugSnag grew up on mobile crash reporting, and server support sits alongside it rather than at the centre.
### Instrumenting the app
Both SDKs required initialization and Express integration, but their middleware placement differs. BugSnag uses a request handler ahead of your application routes and an error handler after them. That first position matters: middleware that executes before BugSnag's request handler is outside its request context. Sentry has its own SDK initialization and error-capture flow, so follow the instructions for the installed SDK version rather than treating the two snippets as interchangeable.
| What the SDK gives you | Sentry | BugSnag |
|---|---|---|
| Error capture in Express | ✔: error handler after routes | ✔: requestHandler first, errorHandler last |
| User on each error | ✔: setUser | ✔: setUser, scoped to the request |
| Breadcrumbs | ✔: addBreadcrumb | ✔: leaveBreadcrumb |
| Custom metadata | ✔: contexts | ✔: addMetadata in its own tab |
| Sessions for release health | ✔: automatic | ✔: automatic, one per request |
| Custom spans | ✔: startSpan | ✘: OpenTelemetry instead |
| Logs and metrics | ✔: logger and metrics APIs | ✘: not offered |
| Flush on exit | ✔: flush | ✘: no flush call in the Node SDK |
Once configured, both SDKs captured the deliberately generated errors and attached users, breadcrumbs and metadata. The bigger difference was how much related performance and debugging data I could explore after opening an error.
[summary]
If you're weighing Sentry because of its SDK, you can keep that SDK and still try something else. I pointed the same monitoring-lab adapter at a Better Stack DSN and changed nothing else. All six bugs arrived as six separate errors, with source lines, the checkout breadcrumbs and the user attached.
This is the resulting error list from that adapter test; it is an additional observation rather than part of the Sentry-versus-BugSnag scorecard.
**[Point your Sentry SDK at Better Stack](https://betterstack.com/error-tracking)**
[/summary]
## Capture and grouping
Both tools created six distinct issues for the six failures. That matters because a merged error group can hide a second root cause. Here, Sentry separated the missing-book and bad-coupon `TypeError` exceptions into issues 66-5 and 66-3. BugSnag also kept them separate, pointing to `server.js:38` and `server.js:81` respectively.
The Sentry list establishes the baseline: six independent failures, each with its own issue to triage.
BugSnag made another distinction easier to scan. Every row carries a handled or unhandled badge, and the sidebar splits errors into "For review", "Assigned to me", "Fixed", "Snoozed" and "Ignored" before you type anything.
| Error | Sentry | BugSnag |
|---|---|---|
| Missing book TypeError | ✔: own issue | ✔: own error |
| Bad coupon TypeError | ✔: own issue | ✔: own error |
| Out of stock | ✔: own issue | ✔: own error, handled |
| Upstream 503 | ✔: own issue | ✔: own error |
| Broken promise | ✔: own issue | ✔: own error |
| Sales report job | ✔: own issue | ✔: own error, handled |
BugSnag's grouping settings also let you group by error class or by error context, which helps if your stack produces noisy messages.
### Sentry dropped some repeated events
In my Sentry runs, the app logged more failures than Sentry recorded. In one run, the `title` bug wrote 14 log lines and Sentry counted 10 events. Stats showed the gap as "Client Discard / Event Processor", which is consistent with the SDK dropping identical errors that arrive back to back.
I did not run an equivalent event-by-event count reconciliation for BugSnag, so this is **not** evidence that BugSnag counted every occurrence. The general lesson is to distinguish application failures, SDK submissions and accepted events. If event volume drives triage or billing decisions, reconcile the numbers against application-side records.
[summary]
Checking error counts against logs is tedious in either tool. In Better Stack, errors and logs live together, so I asked AI SRE to do it. For release 1.1.0 it matched 50 exceptions against 55 failed-request log lines, named the two errors that lost events, and confirmed the coupon bug was the only one that came back.
**[Investigate errors with AI SRE](https://betterstack.com/ai-sre)**
[/summary]
## The error detail page
### Stack traces
Sentry showed the crashing line with source lines 76 to 86 inline, read from the files on disk, with no repository connected. Framework frames were collapsed under the one in-app frame.
In my BugSnag setup, the same error showed `server.js:38:45` and Express router frames, plus a "Raw view" toggle, but no inline source excerpt. The frame still told me where to look; I just had to open the file separately. Repository and source-mapping setup may change what a different project displays.
### Breadcrumbs, user and metadata
This is where BugSnag holds its own. On the coupon error, its Breadcrumbs tab showed a timeline with a type filter and a search box: "Error Occurred", then the manual "book found" breadcrumb with bookId, title and stock. Sentry showed the same breadcrumbs as a timeline at the top of the issue.
Sentry presents those steps on the issue page instead of requiring you to open a separate breadcrumb tab. Both gave me the sequence I needed to reconstruct checkout.
BugSnag puts the user in its own tab, and the custom context from my handled OutOfStockError landed in a DETAILS tab with bookId 7, email and quantity 1. Sentry showed the same data as a user tag, a User context and a "details" context panel.
BugSnag's newest tab, Correlated events, lists other errors from the same user and session. On carol's coupon error, it showed her OutOfStockErrors from the same session. Sentry's answer is different: the issue page links to the related logs and the request's trace.
That view helps answer a different question from a trace: whether this person experienced another failure in the same session, even when the errors happened on separate requests.
| Detail | Sentry | BugSnag |
|---|---|---|
| Source lines | ✔: 11 lines inline | ✘: frames only |
| Breadcrumbs | ✔: timeline | ✔: timeline with search |
| User | ✔: tag and context | ✔: own tab |
| Custom context | ✔: own panel | ✔: own tab |
| Related data | ✔: logs and trace | ✔: correlated events by user and session |
| Async rejection | ✔: mechanism and frame | ✔: one frame, unhandled |
### Async errors
The unhandled promise rejection is a good stress test. Sentry tagged it with mechanism `auto.node.onunhandledrejection` and the frame in `loadRecommendations`. BugSnag caught it as unhandled with the single frame `server.js:144:9 loadRecommendations`.
## Finding errors: search and filters
I asked both tools to find Bob's checkout failures. Sentry let me combine the user, environment, release and URL in one query:
```
user.email:bob@example.com environment:development release:monitoring-lab@1.0.0 url:*checkout*
```
That Sentry query returned two issues. I then searched BugSnag by `userEmail:bob@example.com`, which also returned two errors: the coupon TypeError (3 events) and OutOfStockError (4 events). **These searches are not strictly identical:** my BugSnag filter was only by email, while the Sentry query also constrained release, environment and URL. Both demonstrated usable field filters, not equivalent matching counts.
BugSnag's resulting inbox has fewer filter dimensions in the example, but it still quickly surfaces the two related checkout failures.
| Search task | Sentry | BugSnag |
|---|---|---|
| Filter by user | ✔: user.email | ✔: userEmail |
| Filter by release | ✔: release | ✔: Release and Feature picker |
| Filter by stage | ✔: environment | ✔: Stage picker |
| Saved searches | ✔: saved views | ✔: saved filtersets |
| Search inside breadcrumbs | ✘: not on the issue | ✔: breadcrumb search box |
## Triage
Error capture is only the beginning of team triage. You also need a way to record ownership, suppress known noise and decide when an issue is truly resolved. Both products handle those basics, but they express resolution differently.
Sentry's "Resolved In" menu offered the next release, the current release, another release or a specific commit. Archive had five conditions, and merge lived in the bulk bar.
BugSnag's toolbar has Assign, Mark as fixed, Fix with MCP, Snooze and Ignore. Mark as fixed opens a dialog for an optional Markdown comment, and the activity log then records the error as fixed "Until this error occurs again in a new version". Snooze offers four conditions: until it occurs again, occurs again after a time, occurs at least a number of times, or impacts more users.
| Triage action | Sentry | BugSnag |
|---|---|---|
| Resolve | ✔: now, next release, release or commit | ✔: fixed until a new version |
| Snooze or archive | ✔: five conditions | ✔: four conditions |
| Assign | ✔: assignee | ✔: assign |
| Priority | ✔: high, medium, low | ✘: not on the error |
| Merge | ✔: bulk bar | ✘: not seen |
| Comments | ✔: activity box | ✔: comments and activity |
| Auto-fix on release | ✔: off | ✔: off by default |
## Releases and regressions
### Releases
Both products populated release views from the version metadata I set in their SDKs. That is **release recognition**, not proof that every deployment-related feature works without a deploy integration; commit lists and richer deployment context can require additional setup.
Sentry listed 1.0.0 at a 90.364% crash-free session rate with 6 new issues, and 1.1.0 at 90% with 0 new issues. The 1.1.0 release page split issues into tabs, including "Regressed 1".
BugSnag listed 1.0.0 at 83.103% session stability across 290 sessions and 1.1.0 at 83.893% across 298, both labelled "Critical stability" against its default 90% threshold. The 1.1.0 release page showed 50.68% adoption, the errors seen in that release, and an empty "Errors introduced" tab, which was correct, since I hadn't shipped a new bug.
**Do not rank these products by 90% versus 83%.** They were different traffic runs and different denominators. In this Node.js test, BugSnag's Express session tracking counts requests as sessions. These figures are useful within each tool to compare one version with another, not as a head-to-head reliability score.
### Regressions
I resolved the bad coupon bug on 1.0.0, shipped 1.1.0 without fixing it, and sent the same traffic.
In Sentry, the coupon issue reopened as "Regressed in 1.1.0", with "Unhandled | Regressed" in the header, a "Regressed" trend label in the list and its own entry under the release's Regressed tab.
BugSnag reopened the same error, and its activity feed said "Reopened by BugSnag, This error occurred in 1.1.0". The error's Releases summary showed 51.9% of its events on 1.1.0. In the inbox, though, the row had no regressed badge and no filter, so you'd only notice the reopen by opening the error or watching its count grow.
The activity entry confirms that BugSnag did detect the regression. The usability difference is where you have to look to discover it.
| Release feature | Sentry | BugSnag |
|---|---|---|
| Release created from SDK | ✔: yes | ✔: yes |
| Stability per release | ✔: crash-free sessions | ✔: session stability |
| What reopened after 1.1.0 | ✔: only the resolved issue | ✔: only the fixed error |
| Regression label in the list | ✔: Regressed | ✘: none |
| Regression in the release view | ✔: Regressed tab | ✘: Errors seen and introduced only |
| New errors per release | ✔: 0 on 1.1.0 | ✔: none introduced |
[summary]
I ran the same regression test against Better Stack. After 1.1.0, only the coupon error changed status, to "Reoccurred", in the error list itself, and the release showed 0 new errors. "View logs" on that error jumped straight to its "POST /checkout failed" log line through the trace ID.
**[Track releases and regressions in Better Stack](https://betterstack.com/error-tracking)**
[/summary]
## Performance and tracing
This was the biggest **out-of-the-box difference in my setup**, but not a comparison of fully instrumented performance products.
Sentry traced every request through the same SDK. The /search trace showed a 1.99 s request in which the database span took 0.23 ms, so the time was in code, not the query. The /prices trace isolated a 3.54 s outbound call that returned HTTP 503.
BugSnag's Perf tab has Page Loads, Inbound Requests, Outbound Requests and Custom Spans, but it was empty in my experiment. The page prompted me to enable performance monitoring with OpenTelemetry. **That does not mean BugSnag lacks tracing.** Its [Node.js performance guide](https://docs.bugsnag.com/performance/integration-guides/node/) documents OpenTelemetry-based instrumentation. I did not complete that separate setup, so I cannot compare its trace waterfalls or latency breakdowns to Sentry on equal footing.
One confusing detail: two default performance monitors displayed "Alerting" before I had ingested performance data. That made the empty page harder to interpret.
| Performance feature | Sentry | BugSnag |
|---|---|---|
| Server traces in this test | ✔: captured | Not configured; supports OpenTelemetry |
| Percentiles per endpoint | ✔: available in test | Not measured: no performance spans sent |
| Outbound HTTP calls | ✔: http.client spans | Not measured in this test |
| Background jobs | ✔: job trace | Not measured in this test |
| Profiling | ✔: CPU profiles | ✘: not offered |
[summary]
You don't need a second SDK to get traces next to your errors. The same Sentry spans landed in Better Stack as traces, and the `/prices` failure read as one story across both services: a failed span with HTTP 502, the API's outbound call, and the price service's own span nested under it.
**[Explore traces in Better Stack](https://betterstack.com/tracing)**
[/summary]
## Profiling
Sentry provided CPU profiling in this setup; I did not find an equivalent native CPU profiler in BugSnag's tested workflow. With `@sentry/profiling-node` running, the /search profile pointed at one function at `server.js:98:20` that took 1.91 s, 96.23% of the request. The sales report profile showed `buildReport` at 882 ms. Getting there wasn't smooth: the Profiles tab on the transaction summary was empty, and I had to go through the trace instead.
The profile narrows the investigation from a slow HTTP endpoint to the function consuming almost all of its runtime.
## Logs and metrics
BugSnag did not provide a general-purpose logs explorer or application metrics explorer in this test. If you want to analyze structured logs and business counters alongside errors, you would use a separate service or choose a platform that includes those signals.
Sentry's Logs explorer held my structured app logs, each with attributes and a link to its trace. Metrics worked for business numbers too: grouping checkout revenue by coupon gave me none 2,652.89, SAVE10 442.79 and HALFOFF 118.99.
The coupon breakdown is a simple example of using application metrics for a business question rather than a conventional latency chart.
[summary]
If you pick BugSnag for its error workflow, logs still need a home. In Better Stack, my app logs went to the same place as the errors and traces, and every log line carried the trace ID, so an error's "View logs" link landed on the exact request that failed.
**[Search your logs next to your errors](https://betterstack.com/log-management)**
[/summary]
## Alerts and integrations
Sentry's issue alerts have triggers, filters and throttling, plus monitors for metrics, crons and uptime. My UpstreamError alert fired twice during the test.
BugSnag groups its integrations by job: team notifications for Slack and Datadog, issue trackers for Jira and Trello, incident management for PagerDuty, and data forwarding for webhooks and Splunk. Each error also has a "Create or link an issue" panel.
| Integration | Sentry | BugSnag |
|---|---|---|
| Slack | ✔: native | ✔: native |
| Microsoft Teams | ✔: native | not checked |
| Jira | ✔: native | ✔: native |
| Trello | ✘: not listed | ✔: native |
| PagerDuty | ✔: native | ✔: native |
| Datadog | not checked | ✔: team notifications |
| Splunk and webhooks | ✔: webhooks | ✔: data forwarding |
| GitHub and GitLab | ✔: native | ✔: source control links |
## AI
Neither AI workflow was exercised, so I cannot judge its fix quality. In my Sentry project, Seer's workflow requested a GitHub or GitLab connection; in BugSnag, "Fix with MCP" opened a setup prompt for the SmartBear MCP Server. Those were the blockers I encountered, not universal prerequisites for every AI capability each vendor may offer.
[summary]
Seer wanted a repository and BugSnag wanted an MCP server. Better Stack's AI prompt tab needed neither. On the coupon error, it generated a ready-made prompt for Claude Code, Cursor or Codex, plus a plain-language explanation that pointed at line 81 and noticed the request used `save10`, which isn't a key in `COUPONS`.
**[Debug errors with your coding agent](https://betterstack.com/error-tracking)**
[/summary]
## Pricing and trials
Both onboarding flows offered a 14-day trial without asking me for a payment card. Sentry's trial screen listed post-trial free allowances of 5,000 errors, 5 GB of logs, 5 million spans and 5 GB of metrics per month. Published Sentry plan examples listed Team at $29/month and Business at $89/month at the time I checked. **Treat those figures as a snapshot, not a quote:** usage, billing frequency and optional features affect the eventual bill. Check [Sentry pricing](https://sentry.io/pricing/) before buying.
BugSnag's billing screen listed "Error monitoring: Trial Plan" and "Performance: Trial Performance" separately. Its public price image and in-app screen below provide context, but the draft did not establish a consistent, comparable monthly price at the same event and span volumes. I would not present a fabricated cheapest-plan comparison; use [BugSnag pricing](https://www.bugsnag.com/pricing/) to build a quote for your own usage.
For a fair cost comparison, estimate monthly error events **and** trace spans, check included retention and overage rules, and account for any separate log service you would keep with BugSnag.
The account billing view is important because it makes the separation between error monitoring and performance usage explicit.
## What each tool got right and wrong
### Sentry
| Pros | Cons |
|---|---|
| ✔: inline source with no repo | ✘: Dedupe drops repeated events |
| ✔: regressions labelled everywhere | ✘: profiles hard to reach from summaries |
| ✔: configured traces and profiling connected to errors | ✘: more interface to learn |
| ✔: logs and metrics next to errors | ✘: log number filters need tags syntax |
| ✔: resolve by release or commit | ✘: Seer needs a connected repo |
### BugSnag
| Pros | Cons |
|---|---|
| ✔: clear handled and unhandled badges | ✘: no source lines in stack traces |
| ✔: searchable breadcrumb timeline | ✘: reopens only show in activity |
| ✔: correlated events by user and session | ✘: performance needs OpenTelemetry |
| ✔: session stability per release | ✘: no logs or metrics |
| ✔: focused error-monitoring interface | ✘: confusing default performance monitor status in my empty project |
## Which one should you pick?
| Your team or use case | My recommendation | Main caveat |
|---|---|---|
| Mobile and server apps in one place | **BugSnag** | Bring OpenTelemetry for server performance |
| A backend where slow requests matter | **Sentry** | More setup and a busier interface |
| You want release stability without extra setup | **Either** | Both track sessions automatically |
| One team triaging a shared backlog | **Sentry** | Priority and merge are only in Sentry |
| You already run separate logs and APM | **BugSnag** | You'll still switch tools to investigate |
Choose BugSnag if your team mainly needs to triage errors and compare stability between releases, particularly if logs and tracing already live somewhere else. Its handled/unhandled badges, searchable breadcrumbs and correlated events help you understand an individual failure quickly. Its fixed-until-a-new-version behavior also gives a simple, predictable regression workflow, even though the reopened state was easy to miss in the list.
Choose Sentry if the question after an error is usually "what else was happening?" In this test, inline source, explicit regression labels, a trace waterfall and CPU profiling let me identify the expensive function without leaving the product. That breadth brings more instrumentation options and more UI to learn, but it reduces context switching.
## Final thoughts
Both tools passed the first test: six failures became six distinct issues. Both also passed the regression test: the unresolved bugs stayed open, and the one I marked fixed came back in version 1.1.0.
The practical difference was **how quickly I could notice and investigate what changed**. BugSnag made the error itself easy to understand and kept release triage straightforward. Sentry made the return of a fixed bug visible in more places, then connected the investigation to source, traces, profiles and logs.
When you evaluate them, recreate one of your own recurring production bugs and ask two questions: **Will the right person notice when it returns? And can they find the cause without stitching together three tools?** The answers matter more than the number of checkmarks on a feature table.