Sentry gives me the full picture of what's happening in my app at any given time. The UI makes it easy to navigate — error grouping, stack traces, and breadcrumbs are laid out in a way that actually makes sense. When something breaks, I'm not left guessing: it pinpoints exactly where things went wrong and why, down to the specific line of code.

The integration with Next.js and our CI/CD pipeline was straightforward, and performance monitoring has helped us catch bottlenecks we wouldn't have noticed otherwise. The AI-assisted issue triage is a nice touch too — it helps prioritize what actually needs attention. It's the kind of tool that makes you wonder how you ever shipped software without it. Review collected by and hosted on G2.com.

The initial setup and configuration can take some time to get right, especially when fine-tuning alert thresholds to avoid noise. Review collected by and hosted on G2.com.

Sentry has become the industry standard for error tracking because it shifts the focus from "something is wrong" to "here is exactly how to fix it."

The "magic" of Sentry lies in its ability to provide a timeline of events leading up to a crash. It captures:

Breadcrumbs: A trail of user actions (clicks, navigation, API calls) that occurred right before the error.

Session Replay: A video-like reproduction of the user's screen, allowing you to see exactly what they saw without asking them for a screenshot.

Stack Traces: Direct links to the specific line of code in your GitHub or GitLab repository that caused the failure Review collected by and hosted on G2.com.

Duplicate Issues: Sometimes slight variations in a stack trace (like different line numbers in different versions) cause Sentry to treat the same bug as two separate issues, leading to duplicate notifications. Review collected by and hosted on G2.com.

Clear, actionable error tracking

Instead of dumping raw logs, Sentry groups similar errors, shows stack traces, and highlights the root cause—so you’re not digging through noise.

Great developer experience

The UI is clean and intuitive, and the setup for most frameworks (JavaScript, Python, etc.) is straightforward. You can get useful insights with minimal configuration.

Real-time alerts that actually matter

It notifies you when something breaks, but with smart grouping so you don’t get spammed with duplicate alerts.

Powerful context & debugging tools

You get breadcrumbs, user sessions, request data, and environment info—basically a replay of what led to the error.

Performance monitoring + tracing

Beyond crashes, it helps track slow transactions and bottlenecks, which is huge for improving user experience.

Integrations that fit dev workflows

Works well with tools like GitHub, Slack, Jira, etc., so issues flow naturally into your existing process. Review collected by and hosted on G2.com.

Self-hosting is not trivial

While it’s open-source, running your own instance of Sentry reliably at scale requires significant infrastructure and maintenance effort. Review collected by and hosted on G2.com.

What I like most about Sentry is the depth and quality of the information it provides when investigating application issues. The error logging is extremely detailed, allowing users to drill down into exceptions, stack traces, device information, and environmental data to better understand the root cause of problems.

The session replay functionality is particularly valuable, as it provides visibility into the actions performed by users leading up to an error, making troubleshooting significantly more efficient. The platform also offers useful insights into user impact, device types, operating systems, and geographic distribution, helping teams understand how widespread an issue may be.

In addition, Sentry's customizable dashboards and reporting capabilities make it easy to monitor application health, track trends, and focus on the metrics most relevant to different stakeholders. From a Business Analyst perspective, it provides a clear view of application behavior and user experience, enabling more informed discussions with development teams and faster identification of potential issues. Review collected by and hosted on G2.com.

the main area where I believe Sentry could improve is its user interface and overall navigation experience. While the platform provides a wealth of valuable information and powerful diagnostic capabilities, the sheer volume of features and data can make it difficult for new or infrequent users to find what they are looking for quickly.

There is a noticeable learning curve when navigating between dashboards, issues, traces, and session replays, and some workflows can feel less intuitive than expected. Simplifying the interface, improving navigation, and making key features easier to discover would help users realize the full value of the platform more quickly. Review collected by and hosted on G2.com.

The AI assistant is very cool. I've used it to make new dashboards from scratch, and to debug issues. It's saved me hours of tedious work. It takes a little bit of prompt engineering sometimes, but it's free and fairly easy to use. Very cool! Review collected by and hosted on G2.com.

I wish the free tier weren't more restrictive. Maybe that's selfish of me. But I'm between jobs and making passion/resume projects, so I can't afford the $100+ monthly for all the paid tiers of all the services I use. Review collected by and hosted on G2.com.

I like that Sentry catches issues that show up on real devices that I can’t always test myself. It’s especially helpful because my app, Vulpo, connects to people’s Home Assistant server, and every setup is a little different. I also appreciate the stack traces and debug symbolication, since they give me detailed errors with the exact lines of code that triggered the problem. On top of that, the initial setup was really easy.

The UI/UX is strong overall, although a few elements feel a bit too buried. There are also a lot of integrations; I don’t use most of them right now, but it’s good to know they’re available if I ever need them.

Performance could be better, especially with Session Replay enabled on iOS with SwiftUI, where it can cause some micro-hangs. If I don’t use Session Replay, performance is great. Pricing is also great, with a generous free tier and paid plans that feel fair.

The AI/Intelligence features are fairly useful, but they aren’t the main reason I buy in. Seer (the code review) is something I can’t fully trust with a relatively large codebase, but it’s still nice for a first assessment of an issue. Review collected by and hosted on G2.com.

Not much to complain honestly. Would love an app for my phone. Review collected by and hosted on G2.com.

I really appreciate the error monitoring in Sentry; I think it's the best feature. I find the metrics and performance, particularly the traces, very useful. Diving into a request on both the frontend and the backend and being able to quickly pinpoint where the majority of the time is being spent is extremely useful. Also, the initial setup of Sentry was very easy, which was a big plus. Review collected by and hosted on G2.com.

We recently turned on logs via a trial and started sending all the logs from our app to it. I think it's hard to see how much it will cost. I'm sending a 100 gigabytes of logs every day, and that will cost us a bunch of money and we're not gonna do that. So I need to figure out now how to trim that down into a reasonable dollar number for us. Review collected by and hosted on G2.com.

I really enjoy Sentry's ease of integration, i've worked on a lot different codebases, and Sentry is always very easy to integrate regardless of the architecture.

Recently, i integrated Sentry on a pretty distributed app architecture, and we were able to get traces from React, Node and Rust, and using trace continuation across Typescript, TSX and Rust.

I also use Sentry's notifications on Slack, so i can follow specific labels, for errors on the modules that i'm the owner of. Review collected by and hosted on G2.com.

I think this is user error, but it's very easy to get a noisy Sentry if not configured correctly.

When integration you need mainly uncaught exceptions are logged into sentry, and any important errors, such a specific integration thats key to your app.

I try to avoid having captureException calls around, and having a good architecture that makes it so actual exceptions, DB errors, Library Errors, etc, do make it to the top level. Review collected by and hosted on G2.com.

I like that Sentry makes it easy to add observability with logs, traces, and metrics across different programming languages and frameworks. The API and SDK are clean and easy to use, and the integration with frameworks like Java Spring Boot and Go with Gin, as well as our loggers, is seamless. The instrumentation of use cases is straightforward with OpenTelemetry. Sentry's dashboard provides metrics that we previously had to gather with SQL queries. Logging and tracing help us quickly identify and fix problems, improving performance and enhancing customer experiences. The integration and setup are very easy, adding both ease and speed to our software projects. Review collected by and hosted on G2.com.

Nothing at all Review collected by and hosted on G2.com.

Sentry has grown from a basic error-reporting tool into an indispensable “intelligence layer” that genuinely changes how a development team operates. Instead of relying on static logs, it acts like a “black box” flight recorder for applications. Features like Session Replay and Breadcrumbs let me see the exact sequence of user actions leading up to a crash, which removes the usual “can’t reproduce” dead end and saves hours of manual debugging every week.

In 2026, the addition of the Seer AI agent has taken this a step further. Rather than spending time digging through stack traces, I can lean on the AI to correlate latency spikes with specific code deployments and even suggest automated fixes directly via GitHub. It creates a proactive workflow where the system can flag the “suspect commit” and route it to the responsible developer before a single user report ever reaches the support desk.

The platform’s UI is dense, but it’s thoughtfully structured to cover everything from frontend Web Vitals to deep backend distributed tracing. I can trace a single request from a button click in the browser, through multiple microservices, all the way down to a slow SQL query, and that visibility delivers an incredible ROI when optimizing system performance. The recent move to a simplified “per-contributor” pricing model also removes the constant anxiety of managing event quotas during traffic spikes, making it much easier to scale. While the sheer volume of data can still feel overwhelming if alert rules aren’t tuned well, the onboarding is smooth, and the integrations with tools like Slack, Jira, and even MCP-enabled IDEs make Sentry feel less like a third-party service and more like a core part of our engineering team’s nervous system. Review collected by and hosted on G2.com.

While Sentry is a powerhouse for observability, it isn’t without some friction—especially as the platform expands into more specialized areas. One of the biggest pain points for me is the growing density of the UI/UX. As Sentry adds features like Session Replay, Profiling, and Crons, the sidebar and overall navigation have started to feel cluttered, and it can be hard for new team members to locate specific settings without a steep learning curve. I’d love to see a more modular interface that lets users hide sections they don’t use regularly, so there’s less visual noise and the core workflows stay easy to find.

Another area that could use attention is the noise-to-signal ratio in alerting. The issue grouping intelligence is strong, but the initial setup for Inbound Filters can be tedious and time-consuming. We often end up with Slack channels flooded by noise from legacy browsers or third-party browser extensions—errors that aren’t really relevant to our source code or actionable by our team. If the AI-driven filtering could better recognize and suppress these kinds of non-actionable junk errors out of the box, it would make a noticeable difference in the day-to-day developer experience.

On pricing and ROI, the move toward contributor-based pricing in 2026 has simplified things, but the cost of data retention and Session Replay sampling can still feel prohibitive for high-traffic applications. If you’re not extremely careful with sampling rates, it’s easy to pay a premium for data you’ll never actually review. A more granular, automated smart sampling option—where Sentry records replays only for sessions that lead to an error or high latency—would help maximize the platform’s value without the ongoing manual overhead of tuning quotas. Finally, while Seer AI is impressive, it occasionally hallucinates fixes for complex, logic-heavy bugs; more transparency into how it arrived at its conclusions would make it a much more trusted partner in the debugging process. Review collected by and hosted on G2.com.