Pains

Limitations of Next.js server functions force developers to use alternatives like tRPC for some backend tasks, resulting in inconsistent architectural patterns and parallel caching systems. This fragmentation increases complexity.

TypeScript struggles with objects assembled dynamically at runtime in value space. Developers must manually explain type relationships using complex features like const assertions, mapped types, and type assertions, making it cumbersome to work with dynamically constructed data.

Performance optimization has emerged as the #1 operational challenge (46%), displacing earlier basic adoption concerns. Organizations struggle to optimize performance across databases, AI/ML, and traditional containerized workloads simultaneously.

TypeScript's type system assumes variables have exactly one type and cannot change types. When building objects iteratively through mutations in for loops, TypeScript cannot model these intermediate state transitions, making it impossible to properly type such functions without workarounds like 'as' assertions.

Python is slow because it is not compiled, making it unsuitable for performance-critical applications compared to compiled languages.

Next.js's conventions and built-in features, while streamlining development, limit flexibility for custom configurations or workflows. Companies with unique requirements struggle with routing, data fetching, or build process customization.

Learning Next.js requires mastering not just React, but also its routing model, rendering modes, proprietary caching behavior, deployment quirks, and middleware runtime. This multi-layered complexity creates a steep onboarding barrier for newcomers.

The previous 10GB cache limit forced teams with large dependencies or multi-language monorepos to have build dependencies evicted before the next workflow run, requiring repeated downloads and slowing builds. While recently increased, this was a long-standing pain point.

Modifying the Docker Compose version field can silently disable features. Advancing the version makes previously valid compose files invalid, and there's no clear migration path or warning system.

GitHub Actions are stateless, making it difficult to reuse computation within VMs without relying on external tools like Make or Just. Even with caching layers, developers cannot reliably persist state between runs, forcing redundant rebuilds and slowing feedback loops.

Middleware that runs on every request with large libraries or poor tree-shaking increases TTFB, which directly affects FCP and LCP metrics.

Using 'any' in TypeScript bypasses all type checking, leaving developers vulnerable to runtime errors that should have been caught at compile time. This common anti-pattern defeats the purpose of using TypeScript for type safety.

File ownership mismatches occur when mounting volumes, causing "Permission Denied" errors. Requires manual UID/GID matching or SELinux context configuration.

Docker builds are slow on CI/CD pipelines, delaying deployment. Requires manual optimization (reordering Dockerfile, enabling BuildKit) that isn't default behavior.

Developers transitioning from other infrastructure approaches find Docker difficult to master despite initial ease of use. The steep learning curve is compounded by Docker extensions and additional tools that increase platform complexity, and rapid updates that make it hard to maintain proficiency.

Docker inherits UNIX process management design issues where special init processes must be run to handle zombie process reaping. The PID1 signal semantics differ from other processes, causing compatibility problems with applications that don't account for these differences, though this can be mitigated with the --init flag.

Estimating task duration is the most consistent pain point across all developer roles (31% of IT professionals, 42% of experienced developers, 49% of decision-makers). This affects sprint planning and project delivery prediction.

Error handling and debugging in Next.js often leads developers into opaque framework internals, making it difficult to understand and resolve issues. The 'black box' nature of the framework complicates troubleshooting.

Without using next/dynamic, components that aren't needed on initial page load (like modals) get shipped in the main bundle, increasing bundle size and harming LCP, FCP, and INP.

Pull request review is flagged as a top workflow blocker (25% of developers), slowing team coordination and delaying merges. No structured tooling has effectively reduced this friction point.

Running tests from within Docker containers takes excruciatingly long to complete, adding significant overhead to the development and testing workflow.

Misconfigured Kubernetes affinity rules cause Pods to schedule on incorrect Nodes or fail to schedule at all. Affinity configurations support complex behavior but are easy to misconfigure with contradictory rules or impossible selectors.

Unit tests fail during setup (broken dependencies, missing object properties) rather than at assertions. PyTest cannot run tests after dependency refactoring, delaying detection of actual logic bugs.

64% of developers now use non-local cloud environments as primary setup, but this introduces coordination and debugging challenges that weren't present in local-only workflows, requiring new tooling and practices.