Pains

33% of respondents cite securing applications and integrating third-party tracing systems as pain points. Security has emerged as the #1 concern for DoK workloads, driven by complexity of securing distributed data workloads and regulatory compliance.

Upgrading to Next.js 16 causes significant, unexpected increases in build times and output bundle sizes. Projects that previously built quickly now consume more CI/CD resources and produce larger bundles, harming Core Web Vitals.

Moving resources between state files or across state boundaries is not supported by terraform mv or other built-in tools. Teams must manually edit JSON state files or write custom tooling to reorganize infrastructure across projects or environments.

Unlike other IaC tools, Terraform lacks a stack concept for managing collections of related resources. It only operates at the root module level, making it difficult to manage large, complex environments with multiple resource groupings without custom orchestration.

Inadequate network security measures expose AWS applications to external threats. Developers must properly configure VPCs and security groups, which requires significant security expertise.

When something goes wrong in an AWS environment, it is difficult to identify root causes and determine fixes. Error handling across distributed services is complex and time-consuming.

Combining multiple schemas from different data sources into a single coherent schema is complex and time-consuming. Developers must carefully map data relationships and ensure schema consistency, especially in applications with many data sources.

Business logic and jobs stored in PostgreSQL stored procedures have no git version control, exist only in production without documentation of authorship, and cannot be tested in CI/CD pipelines. Debugging is difficult without proper stack traces or logging tools, making maintenance a time-consuming nightmare.

Next.js dev mode is slow and painful; developers must wait for route compilation when checking multiple routes. The development server consumes several gigabytes of RAM, creating frustrating workflow interruptions.

Go's built-in data structures (maps, slices, arrays) are not thread-safe despite the language's strong concurrency support. Developers must manually implement synchronization using goroutines, channels, or the sync package, creating inconsistency in how concurrency is handled.

PostgreSQL lacks native horizontal scalability features. When instance sizes become insufficient, teams experience downtime during scaling operations. Aurora vacuuming and scaling issues persist, and teams desire alternatives like CockroachDB that support true horizontal scaling without downtime.

Build performance remains a major concern with 8,511 GitHub issues. Despite being a core Next.js promise, developers struggle with Turbopack, Babel, and webpack optimization. Experimental features often break existing setups, and slow builds cascade to affect all feature delivery timelines.

Next.js 16 introduces hydration errors where client-side reconciliation doesn't match server-rendered HTML, causing flicker, broken interactivity, and console warnings. This issue is particularly prevalent with the new Server Component paradigm.

Teams implement service meshes, custom CNI plugins, or multi-cluster communication before mastering Kubernetes' native networking primitives (Pod-to-Pod communication, ClusterIP Services, DNS, ingress). This introduces additional abstractions and failure points making troubleshooting extremely difficult.

26% of AI builders lack confidence in dataset preparation and trustworthiness of their data. This upstream bottleneck cascades into time-to-delivery delays, poor model performance, and suboptimal user experience.

Turbopack, Next.js's replacement bundler, complains about valid TypeScript code and struggles to understand `:global` in CSS modules. Despite these issues, it remains unstable and not production-ready.

npm suffers from slow installation times and high resource consumption, particularly in large-scale projects with many dependencies. This impacts developer productivity and build times, with developers finding alternatives like Yarn and pnpm faster.

When enterprises hire large teams of backend engineers, the cost and time to onboard them into Rust is substantial, with most teams expecting months before new hires can contribute meaningfully. This creates significant friction for rapid team scaling.

The linking phase is performed from scratch every time and is a major bottleneck in the build process. Since Rust delegates linking to external system linkers, performance improvements are limited, though the Rust team is attempting to switch to faster linkers by default.

Pure JavaScript in large-scale backend systems allows functions to receive unexpected parameters without enforcement, leading to hidden bugs that are difficult to refactor safely. Consistency across large codebases with hundreds of thousands of lines becomes challenging without static typing.

Manual deployments, inconsistent workflows, and fragmented observability across tools increase on-call load and MTTR. Engineers jump between tools during incidents instead of fixing issues, driving burnout and slower delivery due to constant firefighting.

When making schema changes to evolve the application's data handling, modifications either break tests immediately or don't, creating a worse scenario where tests no longer guarantee correctness. This requires iterative fixing of data integrity issues.

Fetching data in useEffect causes a waterfall effect where component renders trigger data fetches, and nested child components wait for parents before making their own requests. This creates 3+ steps before data even starts moving, resulting in users seeing loading spinners for 3-5 seconds instead of immediate content.

Developers ship applications with hero images that load immediately on page open, including images below the fold that users may never see. This results in 8-second load times on mobile connections, as developers often only test on fast office Wi-Fi rather than realistic network conditions.