Pains

Resend lacks native support for dynamic content generation, localization, or complex personalization logic, forcing teams to implement these features outside the platform or in their application code.

Prisma mandates a single `DATABASE_URL` environment variable for database connections, making it impossible to compose credentials from multiple environment variables injected by deployment systems like Kubernetes. Workaround requires custom entrypoint scripts to concatenate variables.

The Discover feature for querying raw event data is powerful but requires understanding Sentry's event schema, field names, and query syntax. Initial confusion prevented adoption for two months. Visual query builder or better documentation would help significantly.

Developers must learn a custom DSL (Prisma Schema Language) that is neither TypeScript nor SQL. Edge cases like composite keys, database-specific column types, and complex defaults force developers to fight the schema language to express things that are straightforward in raw SQL.

While basic features are free, advanced features and enterprise solutions come with significant costs that can be prohibitive for smaller organizations and individual developers.

Figma's aspect ratio lock works correctly in the properties panel but fails inside auto-layout components. When aspect ratios should remain consistent during dragging or component resizing, they break unpredictably.

Custom dashboards feature has limited customization options, inflexible layout system, and cannot be shared with non-Sentry users without screenshots. Notably lags behind competitors like Datadog and Grafana in capability and polish.

Email templates require technical knowledge to update, limiting who on a team can safely modify email content without risking deployment issues or requiring developer intervention.

Datadog's query syntax, dashboard creation, and monitor configuration assume deep familiarity with metrics and distributed systems. Non-engineers (product managers, support teams) struggle with log exploration and dashboard building despite Notebooks and saved views, whereas competitors invest more in accessibility.

Terraform's merge() function only performs shallow merging, not deep merging of nested maps and objects. This prevents clean composition of default configurations with user-supplied overrides and makes merging multi-level data structures awkward.

Fine-tuning sampling rates requires significant experimentation. High-traffic endpoints generate overwhelming error volumes without proper sampling. Requires careful configuration to balance visibility with costs, but configuration is not straightforward.

Integrating Clerk with other services like Supabase requires careful session management coordination. Developers must ensure Clerk's session is available before initializing dependent services, adding implementation complexity.

Java's verbose syntax requires lengthy declarations for simple tasks, making rapid prototyping and scripting slower compared to terser languages. While modern features like records and var typing help, developers accustomed to more concise languages still find the ceremony cumbersome.

Cramming numerous resources, data sources, and variables into single .tf files becomes increasingly difficult to navigate, troubleshoot, and collaborate on as infrastructure expands, slowing down team productivity.

Java developers new to AI face lack of clear starting points, feeling overwhelmed by variety of AI models and libraries, missing practical step-by-step workflows, and unclear guidance on securely integrating private models into applications.

As a closed SaaS platform, Datadog offers minimal flexibility for custom telemetry processing or monitoring unsupported technologies. Teams must rely on Datadog's roadmap for new features, with no ability to modify platform internals.

Beyond basic setup, leveraging advanced features like transaction tracing, custom dashboards, performance monitoring, custom sampling, and proper release tracking requires significant time investment and learning.

Sentry creates separate issues for the same bug when minor variations occur in stack traces (e.g., different line numbers across versions), leading to duplicate notifications and alert noise.

Developers must run `prisma generate` after schema changes to regenerate types. Forgetting this step causes IDE type errors and is reported as the most common support question. The step blocks the development workflow when running concurrent processes.

Working with JSON data in PostgreSQL requires special operators and functions that are difficult to use, especially with nested structures. While JSON saves time and space, querying it is error-prone.

Datadog's graphical user interface suffers from slow load times when drilling deep into subjects and lacks caching optimization. Dashboards feel cluttered and overwhelming for new users; navigation is non-intuitive. Default dashboards don't help teams ramp up faster, and session replay features are clunky. Minor issues like unit display and search syntax cumberousness add friction.

Initial setup and configuration of Sentry is time-consuming, particularly when fine-tuning alert thresholds to avoid alert fatigue. There is no clear guidance on optimal threshold settings.

Sentry's predefined metrics are insufficient for advanced use cases. Users cannot push custom metrics via API and are limited by missing filters, requiring workarounds to track domain-specific performance data.

MongoDB feels fast with small datasets even without indexes. As data grows, unindexed queries suddenly become slow, forcing full collection scans. Developers often ignore indexing until performance issues force attention.