Sources

This isn't just about incremental updates; it's about a strategic push towards greater efficiency, enhanced developer productivity, and a more robust, scalable foundation for modern applications. I've been tracking Neon's progress closely, and the recent releases are genuinely impressive, addressing key pain points and unlocking new possibilities for architects and engineers alike. … One of the most impactful updates is the introduction of **"instantaneous" compute provisioning**. Previously, while Neon was fast, there was still a noticeable ramp-up time for a new compute instance to become fully available, especially after a period of inactivity. The December 2025 updates leverage a more sophisticated pre-warming and predictive allocation strategy. This means that for common workloads, the perceived latency from a suspended state to a ready-to-query state is now measured in milliseconds, not seconds. This is achieved through a combination of intelligent connection pooling at the Neon control plane and a more aggressive background process for spinning up and stabilizing compute nodes. Furthermore, Neon has expanded its **branching capabilities** with enhanced isolation and performance characteristics. Branching in Neon has always been a killer feature for development and testing workflows, allowing developers to spin up isolated copies of their database without impacting production. The latest iteration offers more granular control over the compute resources allocated to branches, meaning you can now fine-tune the performance profile of a development branch to more accurately mimic production, or conversely, provision minimal resources for quick, isolated tests. This is genuinely impressive because it bridges the gap between ephemeral development environments and the need for realistic performance testing. … For **Next.js API routes**, Neon's ability to spin up compute instances on demand means that your backend logic can be highly cost-effective. When an API route is invoked, Neon can provision a compute node to handle the query, and then suspend it when the request is complete. This is particularly beneficial for applications with unpredictable or spiky traffic patterns, as you're not paying for idle compute time. The "instantaneous" provisioning improvements mean that the perceived latency for users hitting these API routes is minimized, even if the database was previously idle. … The **developer experience** is another strong point. Neon's branching capabilities are a game-changer for Next.js development. Developers can easily create branches for feature development, bug fixes, or A/B testing, each with its own isolated database. This eliminates the "it works on my machine" problem and streamlines collaboration. The integration with tools like Vercel is also becoming more mature, further simplifying deployment pipelines. … One area to watch closely is the **free tier**. Neon historically offers a generous free tier that allows developers to experiment and build small applications without upfront costs. This tier typically includes a certain amount of free compute hours per month and a data storage limit. Understanding the limits of the free tier is crucial for early-stage projects. For production workloads, Neon offers pay-as-you-go pricing that scales automatically. The December 2025 pricing adjustments have aimed to provide more predictable costs for sustained workloads while retaining the benefits of serverless for sporadic usage. It's always advisable to consult the latest pricing page directly, as specific numbers can change. … ## Developer Experience Enhancements in Late 2025 Beyond core database features, Neon has consistently prioritized the developer experience, and the December 2025 releases are no exception. These updates aim to reduce friction, accelerate development cycles, and make working with serverless Postgres more intuitive. … The **documentation** has also been a focus. While always comprehensive, the recent updates include more practical examples, detailed tutorials for common use cases, and clearer explanations of the underlying serverless concepts. This is critical for senior developers who need to understand the "why" behind Neon's behavior, not just the "how." The addition of more code examples for advanced configurations and integrations makes it easier to adopt new features. … Finally, the **developer experience** will continue to be a core focus. Expect deeper integrations with cloud-native platforms, more streamlined deployment pipelines, and potentially even more advanced branching and collaboration features. The goal is to make working with a powerful database like Postgres as seamless as working with stateless serverless functions. Neon's consistent delivery of practical, impactful features suggests that their roadmap is grounded in addressing real-world developer needs and technical challenges.

At the heart of Neon's compelling offering is its fundamentally re-architected PostgreSQL. Traditional PostgreSQL is a monolith, tightly coupling compute and storage within a single instance. This design, while robust, creates inherent limitations in scalability, elasticity, and cost-efficiency in a modern cloud environment. ... Key updates include robust support for PostgreSQL 18, significant advancements in the Data API, the General Availability (GA) of inbound logical replication, and exciting new AI-powered features integrated directly into the developer workflow. We're also seeing expanded observability with more granular metrics and continued focus on developer tooling, including a more streamlined CLI experience. ## Performance Benchmarks: Unpacking Real-World Gains and Trade-offs When we talk about serverless, performance immediately brings up the "cold start" elephant in the room. Neon's architecture, while brilliant for cost savings and elasticity, does introduce this consideration. When a compute node scales to zero due to inactivity (typically after 5 minutes), reactivating it can introduce a latency of anywhere from 500ms to a few seconds. I've observed this in testing: a fresh connection to an idle database *will* incur a brief delay. … Furthermore, it's crucial to **set an appropriate minimum compute size** for your production branch. Neon recommends starting with a compute size that can hold your application's working set in memory. **Connection pooling via PgBouncer** is not just a cold-start mitigation but a fundamental component for high-traffic applications on Neon. It efficiently manages thousands of concurrent connections, reducing the overhead of establishing new database connections. … ### Inbound Logical Replication (GA) Neon now fully supports **inbound logical replication**, meaning you can replicate data from an external PostgreSQL instance (e.g., AWS RDS) to Neon. This allows you to establish a publisher-subscriber relationship where your source database acts as the publisher and your Neon project acts as the subscriber. This enables you to cut over your application to Neon with minimal downtime once the target database is fully caught up.

• Because the storage is now a networked system, what new performance/latency challenges does that introduce? How have you addressed them in Neon? ... {ts:572} of your product Vis A what you can get off the shelf from Amazon and then we realized that servus was kind of a big deal and that's when we made a decision to delay our release and it delayed our release by at least six months and ship ... {ts:809} different plugins and some of the ways that you're orienting towards that developer experience by removing the operational concerns well I think there are two questions in one here one is how do you maintain compatibility with postgress in ... {ts:1045} hundreds of thousands of them all at the same time on on our platform so basically the answer how do you deal with the you know massive ecosystem of post is well through that architecture we don't break out compatibility because the engine itself is still posterous uh is just with {ts:1064} swapping out storage uh from under press and the API to storage is so small uh that it doesn't app compatibility so developers don't suffer but do do they Thrive that's another question so and what are the things that developers need to thrive well some of {ts:1085} the stuff is silly you know you go and uh launch an RDS instance it's not connected to the internet and if you run cloudflare workers it's a gigantic pain to connect your application to the database um you know certain things {ts:1102} don't support TCP connections so that's why we launched our servol as driver hosas doesn't do very well with lots of connections and therefore there are systems like poers or PG bouncer that allows you to scale number connections to postest so part of the value is just packaging all that and make it it stupid simple to consume never run out of con … {ts:1505} environment but I'm I'm sharing that staging environment with my whole team let's say my team is tens of people maybe hundreds of people they all need a stageing environment and they all changing schema because they're building the app now they conflicting on both their resources but then the a {ts:1522} centralized resource is just the state of that database so you can't have a but if you want to have a staging environment on a per developer and God forbid they also test in performance now you you have hundreds of copies of that not only hard to manage it's also inefficient from the cost standpoint now

At the heart of Neon’s compelling offering is its fundamentally re-architected PostgreSQL. Traditional PostgreSQL is a monolith, tightly coupling compute and storage within a single instance. This design, while robust, creates inherent limitations in scalability, elasticity, and cost-efficiency in a modern cloud environment. For a deeper look at how this compares to other modern providers, see our guide on Serverless PostgreSQL 2025: The Truth About Supabase, Neon, and PlanetScale. ... Key updates include robust support for PostgreSQL 18, significant advancements in the Data API, the General Availability (GA) of inbound logical replication, and exciting new AI-powered features integrated directly into the developer workflow. We’re also seeing expanded observability with more granular metrics and continued focus on developer tooling, including a more streamlined CLI experience. Performance Benchmarks: Unpacking Real-World Gains and Trade-offs When we talk about serverless, performance immediately brings up the “cold start” elephant in the room. Neon’s architecture, while brilliant for cost savings and elasticity, does introduce this consideration. When a compute node scales to zero due to inactivity (typically after 5 minutes), reactivating it can introduce a latency of anywhere from 500ms to a few seconds. I’ve observed this in testing: a fresh connection to an idle database *will* incur a brief delay. However, Neon has robust mitigation strategies. The primary one is its integrated connection pooler, PgBouncer. By connecting your application through the pooled connection string, PgBouncer maintains warm connections to the underlying PostgreSQL instance, effectively masking many cold starts from your application. My tests show that with a well-configured PgBouncer, subsequent queries after the initial wake-up are consistently fast, often in the sub-100ms range for simple operations. … Furthermore, it’s crucial to **set an appropriate minimum compute size** for your production branch. Neon recommends starting with a compute size that can hold your application’s working set in memory. **Connection pooling via PgBouncer** is not just a cold-start mitigation but a fundamental component for high-traffic applications on Neon. It efficiently manages thousands of concurrent connections, reducing the overhead of establishing new database connections. … **UUIDv7 Support:**Generates time-ordered UUIDs, which are excellent for indexing performance. **OAuth 2.0 Authentication:**Native support for better integration with modern identity providers. Looking further ahead, Neon is targeting **GCP Support** for late 2025, expanding its multi-cloud strategy. They are also planning compute enhancements up to 128 CUs and deeper OpenTelemetry integration for granular observability.

Starting in May, we had a series of feature launches with agentic AI partners that gained far more momentum than we predicted. In two short timespans, the rate of new database creation increased more than 5x, and the rate of branch creation increased more than 50x. While we were humbled by the uptick, the significant burst in operational load caused a lot of strain in the Neon platform, **manifesting as more incidents over the course of the two months than the entire year before. ** … ### May: Capacity Handling and “Cells” May incidents were caused by us hitting a scaling limit around the number of active databases in US regions before our solution (Cells) was ready. Every active database on Neon is a running pod in a Kubernetes cluster. Our testing of Kubernetes showed service degradation beyond 10,000 concurrent databases. Among multiple issues discovered in testing, we approached the EKS etcd memory limit of 8GB and pod start time fell below our targets. In addition, in our us-east-1 cluster, our network configuration limited us to ~12,000 concurrently active databases. In January 2025, we forecasted that we would hit these limits by the end of the year. ... We made various configuration changes to keep our oversized regions functional: tuning networking, reducing our usage of the Kubernetes API to avoid EKS (Amazon Elastic Kubernetes Service) rate limits, scaling up our control plane databases, and shedding load where possible. Each of these changes bought us time to complete the Cells project, but also increased risk of failure and the amount of customer impact when failures occurred — resulting in the incidents you experienced. … ### June: Metadata Handling Database operations incidents in June were caused by scaling issues with our control plane database as a result of a 50x increase in database branch creation. A branch in Neon is a cheap operation – there’s no data copy – but that makes it fast and easy to create thousands of them. In agentic workloads, customers often use branches as “savepoints” to restore app state as their agent iterates on a codebase. *Daily branches created each day by developers (blue) vs agents (yellow)* … - Billing and consumption calculations became more expensive, consuming more CPU - Some queries switched to different Postgres execution plans, and tables became more dependent on aggressive vacuuming - In several cases, customer-impacting issues were caused by control plane queries that went from taking a few hundred milliseconds to over a minute. We have alerting on slow and degrading query performance – but in this case, the query plan switched quickly, introducing service degradation without warning. While we are a Postgres company, we experienced classic Postgres failure modes with increased load: query plan drift and slow vacuum. This is humbling, and will inform our roadmap to help our customers avoid the same. Our test suites were designed around historical usage patterns which didn’t simulate highly skewed project-to-branch ratios. That meant production workloads diverged significantly from what we tested – leading to issues surfacing in production. In this case, we had tested the system at 5x of normal load. But branch creation increased 50x. The system would have continued to function well if we had stronger limits on the number of branches both per project and per customer. One lesson here is that we need stronger limits on EVERY dimension of the workload. Rate limiting at or before our test boundaries would have saved the day. … ### Where to go from here We know the scale of operations is only going to accelerate. Users and Agentic AI platforms are now creating more than 40,000 projects every day. The post-mortems, lessons and patches that have come from these incidents will take us a long way towards a system that can scale exponentially with best-in-class resiliency.

#### 1. The Documentation Desert Look, we get it. Writing documentation isn’t exactly the sexiest part of the job. But here’s the thing: nothing makes a developer’s blood pressure spike faster than trying to decipher a black box of undocumented code. It’s like trying to assemble IKEA furniture in the dark – with someone constantly moving the Allen wrench. … #### 5. Scope Creep: The Silent Assassin It starts innocently enough. A small feature request here, a minor tweak there. But before you know it, the project scope has ballooned out of control, deadlines are looming, and developers are left feeling like they’re drowning in a sea of ever-changing requirements. **The Impact:** Scope creep leads to missed deadlines, compromised quality, and burnt-out developers. Clear communication, well-defined requirements, and a robust change management process are essential for keeping projects on track. #### 6. UI/UX Faux Pas: A Developer’s Nightmare A poorly designed user interface is like a wrench in the gears of a well-oiled machine. It’s not just about aesthetics; a bad UI can make the code more complex, harder to maintain, and ultimately, a nightmare for the developers tasked with bringing it to life. **The Impact:** Investing in good UI/UX design upfront saves time, money, and a whole lot of frustration down the line.

so uh to overcome that problem there is a product that's called PG balancer um that postgres Community recommends to {ts:535.14} put in front of postgres so you can have a lot more what is called pulled connections well uh at neon we do this automatically and so um today we're introducing database connection scaling where we already give you 10 000 pulled connections um and then in the future we'll be scaling even Beyond 10 000 connections with the size of your compute so when you workload we'll start initiating more and more connections which is particularly important in the serverless environments where you know you're operating out of a cloudflare worker or … your data and what do you need to restore and where and maybe you need to set up more more instances to to restore so if you look at this picture there's multiple storage components here and each node primary replica and so forth they control part of the stories or they'll like have their own copy of the storage so the idea with neon is to split that up across the stories layer so that there is only one copy of your database

### 2. Code and Documentation: The Top Pain Points Nearly **one-third of developers** (31%) cited two issues as their biggest headaches: - **Unreadable or hard-to-maintain code** (“as devs call it : the spaghetti code”) - **Insufficient or outdated documentation** Poor coding practices don’t just slow teams down, they create **technical debt** that makes future updates, debugging, and scaling far harder. Without proper documentation, onboarding new developers becomes a nightmare, often forcing reliance on senior engineers and dragging projects behind schedule.

## 66% of developers are frustrated with AI solutions that are almost right The biggest single frustration, cited by 66% of developers, is dealing with "AI solutions that are almost right, but not quite," which often leads to the second-biggest frustration: "Debugging AI-generated code is more time-consuming" (45%) Technology → Admired and Desired … ## Privacy, pricing and better alternatives are top reasons developers turn their back on a technology |Detraction|Overall Rank|Median Rank|Mode Rank| |--|--|--|--| |Security or privacy concerns|1|3|1| |Prohibitive pricing|2|4|1| |Availability of better alternatives|3|4|1| |Poor usability|4|4|4| |Inefficient or time-costly|5|5|5| |Outdated or obsolete technology or features|6|5|8| |Ethical concerns|7|6|8| |Lack of or sub-par API|8|6|8| |Lack of AI or AI agents|9|9|9| |Other|10|10|10| The reasons to reject a technology are nearly universal. The top three deal-breakers for all developers are security or privacy concerns (Rank 1), prohibitive pricing (Rank 2), and the availability of better alternatives (Rank 3). The lack of AI is the least important factor (Rank 9). Technology → Worked with vs. want to work with

Chat with curated Neon database documentation directly in GitHub Copilot and get answers to common questions like: *How to create a project?* *How can I get started with the Neon API?* *How do integrate the Neon API into my GitHub repository.* ... **Increased concurrency limits**. We've increased Neon API operation concurrency limits. Previously, concurrent API operations within a Neon project — such as operations on different branches — could trigger a "project already has running operations" error, where one branch operation would block others. This improvement reduces the need to work around strict concurrency limits. However, we still recommend adding retry functionality to handle rare cases where an API operation fails due to ongoing operations. … - Restored the ability for Enterprise customers to set custom scale-to-zero timeout periods. - Replaced incorrect "insufficient permissions" message with a loading indicator when Organization admins open a project's **Delete**page. - Prevented duplicate installations of the Neon GitHub integration for organizations and personal accounts. - Data sizes are now displayed as

- Fixed an issue with the QuickBooks Online integration where duplicate invoices were created when a synced pledge had a pledge payment including Donor Covered Fees. - Fixed an issue where volunteer shift times displayed incorrectly on mobile devices using Safari. - Fixed an issue where reCAPTCHA appeared twice on Email Newsletter Subscription Forms. - Fixed an issue where membership term length was unexpectedly updated when an incoming account with an installment membership was automatically merged into an existing account which also had an installment membership. - Fixed an issue where accessing a volunteer form through an email with Email Link Authentication enabled provided full access to the Constituent Login Portal. - Fixed an issue where the QuickBooks Sync Date field was populated for transactions included in failed syncs. - Fixed an issue where workflows with conditional triggers could trigger multiple times after accounts were merged. - Fixed an issue where Date type custom fields could be entered with different formats on forms, causing validation issues when editing the resulting records as a user. - Fixed an issue with the import manager where imports could fail if more than 50 columns were mapped. - Fixed an issue where the Update Account Field action did not work as expected in workflows. - Fixed an issue where QuickBooks categories containing special characters could not be imported when configuring the integration. - Fixed an issue where attempting to super delete an account could result in an error if it included an event registration linked to a non-account household contact. - Fixed an issue where updating accounts' zip codes via Bulk Edit or Delete Accounts tool could prevent those accounts from being captured by Duplicate Scans. - Fixed an issue where hidden, pre-selected account fields on forms did not populate for logged-in constituents. These fields will now populate unless there is existing data present on the account. - Fixed an issue where slow network speed could cause duplicate actions to be added in the workflow editor. - Fixed an issue where the Tender Type output column in the Event Registration Report was not accurate for event registrations with multiple payments. - Fixed an issue where accounts with names containing apostrophes encountered issues when editing membership directory profiles. - Fixed an issue where the font color for pop-up form buttons did not update after changing the main button color. - Fixed an issue where legacy donation forms could not be published via their associated fundraising campaign page if they had been previously archived. - Fixed an issue where the Advanced Search became unresponsive if it had previously timed out in the same browser session. - Fixed an issue where an incorrect message appeared when attempting to delete some Themes. - Various behind-the-scenes bug fixes, security updates, and performance enhancements. - Various wording fixes and revisions.

**Neon's advantage:** Neon’s design offers real benefits for AI work, like spinning up separate Postgres instances in "less than half a second" and allowing instant data branching for safe experimentation. Its serverless structure also means costs align with actual use, tackling a common pain point with traditional databases when deploying AI agents.