Pains

Supabase lacks guides for structured database development. Developers must create workarounds like master GitHub repos of SQL commands and custom documentation, making collaboration and migration difficult.

Failing to implement connection pooling is a common mistake in PostgreSQL deployments. Each connection consumes approximately 10MB of RAM, and applications that create new connections for each database operation can quickly exhaust server resources, leading to performance degradation and application failures.

FastAPI does not provide built-in health check endpoints, requiring manual implementation. Missing health checks in production deployments cause cascading failures during infrastructure issues or deployments.

Several important features needed for production usage (e.g., hiding attributes from Swagger, hiding internal documentation from Pydantic docstrings) have had PRs submitted but remain unmerged without maintainer feedback or response.

Resend lacks native support for email preview testing across different email clients, A/B testing, and has no built-in inbox placement testing or blocklist monitoring. Teams must handle these critical deliverability checks outside the platform.

As the ecosystem grows, community packages become obsolete or unsupported. Flutter SDK updates sometimes break backward compatibility, requiring code rework or package alternatives. This fragmentation slows development and creates technical debt in scaling projects.

Knowing when to use useMemo, useCallback, and React.memo adds significant mental overhead for developers. This complexity stems from React's component-based reactivity model requiring the entire component function to re-run on every update, forcing developers to manually optimize with memoization.

Clerk requires paid tiers to enable multi-factor authentication, passkeys, and impersonation features that competitors offer free or include by default, forcing developers to pay for baseline security functionality.

Rust's debugging story represents a significant non-trivial problem for developers, with 19.90% reporting it as a big problem. This issue slipped from 2nd to 4th place in priority ranking from 2024 to 2025.

Flutter apps consume more CPU and memory than native counterparts due to the framework's custom rendering engine. This results in increased battery consumption, especially on lower-performing or older devices, making heavy-computation applications like video processing and AR less suitable for Flutter.

When inheriting applications (whether from contractors or former team members), there is often no documentation about dependencies, installation requirements, database contents, or what components exist. This makes it impossible to know if legacy code can even run without significant reverse engineering.

When FastAPI constructs become the center of the codebase, business logic becomes tightly coupled to the framework, making it hard to reuse, test independently, and maintain long-term flexibility.

React Server Components (RSC) create confusion about client-server boundaries, increase development complexity, and introduce latency. Simple applications feel overengineered due to RSC requirements, creating a steep learning curve and performance concerns with cold starts on serverless platforms.

Flutter apps have significantly larger minimum APK/IPA file sizes compared to native apps, even with optimization efforts. This is a critical blocker for emerging markets and devices with limited storage where download speed and app size are important factors.

FastAPI routers accumulate validation logic, business rules, database queries, and external API calls, becoming mini-applications that are difficult to test, refactor, and maintain.

Resend does not adequately serve serverless and background job-based email workflows that are common in modern technology stacks. Documentation and tooling for these patterns are unclear or insufficient.

As Stripe adds more features and diversifies into Atlas, Capital, and Platform of Platforms, the API complexity grows. This erodes Stripe's original advantage of being super simple to set up.

Supabase's complexity creates barriers for novice developers, compounded by limited community support and insufficient documentation tailored to beginners. The platform requires significant SQL and database knowledge to use effectively.

Codex struggles with truly novel problems, complex logic, and abstract reasoning tasks that deviate significantly from its training data. Its pattern-matching approach makes it ineffective for innovative algorithmic design and entirely new programming paradigms.

Managing AI-generated code with multiple developers working on different sections creates challenges in tracking changes, maintaining version consistency, and preventing changes from being lost or overwritten. This leads to errors, compatibility problems, and wasted time undoing changes.

React introduces paradigms that fundamentally differ from PHP or jQuery workflows. Developers must understand state management, hydration (syncing server-rendered markup with client-side React), and new mental models, creating significant learning friction for traditional WordPress developers.

Stripe frequently updates its API and deprecates features, causing 25% of developers to face integration disruptions due to outdated API practices. Staying informed on changes is labor-intensive.

Stripe is optimized for card payments and US-centric payment methods but has limited support for local payment methods that dominate in regions like Europe, Asia, and South America. Businesses operating internationally cannot fully serve their regional customer bases.

FastAPI's global app object state is difficult to patch in unit tests. Accessing global state requires importing from other files, easily leading to circular dependencies, inline imports, and problematic testing patterns.