Changelog

Safer project deletes

We've heard you. Where it might have felt just a little too easy to delete a project — along with its branches, databases, and roles — we've added a bit more friction to the process. You now have to type out the name of your project by hand before you can delete.

Local File Cache (LFC)-aware autoscaling

As we continue to mature our Autoscaling offering, we've rolled out LFC-aware autoscaling to all regions.

One hour of real-time autoscaling from a selection of your databases.

The idea behind this feature is to improve performance by keeping your entire working set (a subset of frequently accessed or recently used data) in memory. We already recommend this in the docs, and we've now made it a native part of how autoscaling works: your compute now dynamically resizes to fit your working set within the LFC.

If you're not familiar with Neon's Local File Cache (LFC), you can learn more about it here: What is the Local File Cache?

GitHub integration

We've opened up a new feature to all users. Our GitHub integration includes a GitHub app that you can use to connect your Neon projects to GitHub repos.

This new integration makes it easy to:

• Automatically create a database branch with each pull request.
• Build GitHub Actions workflows that interact with Neon. To help you get started, we provide a sample workflow that you can customize.

How it works, in a nutshell:

• Install the GitHub App — the integration installs a GitHub app that you'll use to select repositories you want to connect to Neon.
• Set up variables — the integration sets up a Neon API key secret and a Neon project ID variable in the selected GitHub repository.
• Create workflows — you can then use GitHub Actions to integrate database branching with your workflow for preview environments, testing, and more.

To get started, follow the instructions in our GitHub Integration guide.

We'll be expanding on this feature in future releases. If you have requests or feedback about what you'd like to see in the next update, let us know via the Feedback form in the Neon Console or our feedback channel on Discord.

Password protection for protected branches

When you create a child branch from a protected branch, new passwords are generated for the Postgres roles on the child branch.

This behavior is designed to prevent the exposure of passwords that could be used to access your protected branch. For example, if you designate a production branch as protected, the newly generated passwords for Postgres roles on child branches ensure that you're not exposing product branch credentials in your development and test branches.

The protected branches feature is available with the Neon Scale plan. To learn more, refer to our Protected branches guide.

Improvements for our Free Plan users

For our Free Plan users, we've made a couple of updates to make it easier to track and manage plan allowances:

• We added a Data transfer section to the Billing page in the Neon Console so that you can easily monitor all of your plan allowances in one place. Data transfer is the total volume of data transferred out of Neon (also referred to as "egress") during a given billing period. Neon does not charge for data transfer, but there's a 5 GB per month allowance on the Free Plan. For more, see Data transfer.
• We updated the Resources remaining widget on the Project Dashboard. The Compute time since metric has been renamed to Branch compute time. This metric shows the number of compute hours remaining for branch computes in the current billing period. The Free Plan offers an allowance of 5 compute hours per month on branch computes in addition to 24/7 availability on the default branch compute.

Drizzle Studio updates for our Tables page

We've updated the Drizzle Studio version that powers the Tables page in the Neon Console. Among other updates, this new version of Drizzle Studio brings the following improvements:

• Support for materialized views
• Improved filtering behavior (filtering now occurs when you click Apply)
• The ability to paste a value into a cell without double-clicking
• Delete and update support for tables without a primary key. If there is no primary key, a unique constraint is required. A NULL check is performed if a unique constraint is nullable.

Self-serve logical replication

You can now enable logical replication for your Neon project from the Settings > Beta page in the Neon Console. This feature lets you replicate data changes from Neon to external data services and platforms.

Get started with one of our logical replication guides.

This feature is currently in Beta. If you've got requests or feedback, let us know via the Feedback form in the Neon Console or our feedback channel on Discord.

Clearer language around compute types

Words matter. We've changed our naming convention around compute types: from RW compute and RO Replica to a cleaner, more straightforward Primary compute and Read replica.

With Neon's unique architecture, where we separate storage from compute for copy-on-write branching, you can choose the size and features for the compute that powers your branch's database independently from your data.

• Primary compute — When you create a branch in Neon, a primary compute is automatically created alongside it. You can think of your primary compute as the main engine for your branch. It supports read-write operations, though you can modify database permissions using traditional Postgres roles.
• Read replicas — When you’re ready to scale your application, you can direct read-only traffic to one or more read replicas. Unlike traditional systems where data is physically replicated, Neon’s read replicas access the same data source as the primary read-write compute — at no additional storage cost.

For more information, see:

• Manage computes
• Manage database access
• Read replicas

Neon CLI create-app improvements

The Neon CLI create-app command initializes a new Neon project and bootstraps a full-stack application using your preferred package manager. This feature is very new, but it's maturing fast:

• It now supports Prisma as another ORM option for your bootstrapped application.
• It also now creates two separate branches for your app's Neon project: your main branch and a development branch.

To learn more, see Neon CLI commands — create-app.

Select the right compute size with predefined compute configurations

We've updated the Edit compute and Add new compute drawers in the Neon Console to include predefined compute configurations. With recommended min and max autoscaling settings and autosuspend timeout periods, these configurations make it easier to select the right compute size for your needs.

Computes with more vCPU and memory

We've added support for larger computes with more vCPU and memory. If you're a Neon Scale plan user, you can now scale your computes up to 9 vCPU with 36 GB of RAM or 10 vCPU with 40 GB of RAM.

More branch protection

If you've been following along, you know that we recently added safeguards to prevent you from deleting protected branches. This week, we're extended that protection:

• You can no longer delete a Neon project that has protected branches.
• You can no longer delete computes that belong to protected branches.

The protected branches feature is available with the Neon Scale plan.

Hackable AI starter apps

We've published a new set of hackable, pre-built AI starter apps to help you get up and running with Postgres as your vector store. The set includes different types of AI applications, including:

• AI chatbot
• RAG chatbot
• Semantic search
• Hybrid search
• Reverse image search
• Chat with PDF

Clone an app and make it your own.

For more, check out our new Neon AI Starter Kit, where you'll find links to our starter apps, docs, and a collection of AI applications built with Neon.

Consider sharing your AI app on our #showcase channel on Discord. We'd love to see what you're building.

Updates to the Neon CLI

We've added some terrific new features to our CLI:

• Configurable compute sizing with -cu option, including support for autoscaling

  You can now set your compute size when creating a branch using the CLI. For a fixed compute size, use a single number (e.g., --cu 2). For autoscaling, specify a range with a dash (e.g., --cu 0.5-3).

  Example:

  neon branches add-compute main --cu 0.5-3

  Previously, compute size was determined by your default settings in the console. For more about branching via the CLI, see Neon CLI commands — branches.

• Bootstrap new applications with Neon using the create-app command

  You can now scaffold applications using the CLI with the create-app command. Choose your package manager, framework, ORM, and authentication method, and go. Read the docs for details. This exciting new feature is just getting started. More to come!

Added polish to our Branches page

Branching is still a relatively new concept in the database world, and we want to make your experience with it as intuitive as possible. Here are our latest updates to the Branches page:

• Made it easier to create child branches by adding a clear-as-day Create child branch button to the detailed Branches view. It's still an option under the Actions dropdown, but now you've got the can't-miss button too.
• Easier navigation from your listed database on the Roles and databases tab to the Drizzle Studio-based Tables page, where you can explore and modify your data directly. The actions kebab also includes options to delete your database, as well as navigate to the SQL Editor, and we preserve your database selection as you travel.
• We've changed the metric displayed on the Branches page from active hours to the more helpful compute hours metric, giving you a better sense of how much compute resources a given branch is consuming. For more details about consumption metrics, see Usage metrics.

Even more protection

Last week, we introduced protection against accidentally deleting protected branches. This week, we've added more safeguards:

• Resetting Protected Branches: We now prevent you from using Reset from parent on protected branches (often your production branch) unless you unprotect the branch first.

Fixes & improvements

• Fixed a misleading item in our Quickstart, where we told you that your compute had already started while it was still in transition. Trying to connect in that state would fail. Now, when you see your compute has started, it is definitely started. You can grab your connection string and go.

• The Neon CLI ip-allow command's --primary-only option was deprecated and replaced by a --protected-only option. Additionally, in the Neon API, the primary_branch_only option in the Create project and Update project methods was deprecated and replaced by the protected_branches_only option. The deprecated options will be removed in a future release.

  These are follow-up changes associated with the renaming of "primary branches" to "default branches" that we implemented recently and announced in the June 21, 2024 changelog.

Explore Postgres extensions from the Neon Console

Postgres extensions let you customize and extend your database's capabilities across a broad range of categories: from analytics and data transformation to full-text search and geospatial data processing, and more. Currently, Neon supports over 70 Postgres extensions.

You can now explore all of Neon's supported extensions directly from the console. We've added an Install Extensions section to the Quickstart, which you can open from the Neon Console sidebar.

Click Install to view the required CREATE EXTENSION command, and click Docs to view the extension's documentation.

More protection for protected branches

To better safeguard your protected branches, we've disabled the Delete action for those branches.

Now, before deleting a protected branch, you have to change its status to unprotected.

The Protected branches feature is available with the Neon Scale plan.

Fixes & improvements

• We now preserve your currently selected branch and database when you switch between the SQL Editor and Tables page in the Neon Console.
• Added an Endpoint Inactive legend item to the CPU and Database Size charts on the Monitoring page in the Neon Console. This legend item highlights periods when the compute endpoint was suspended, indicating no available data for those times.
• Moved the system status out of the notifications menu to a system status badge in the main page header, making it easier to check your status in the Neon Console at a glance.
• Added a psql -h pg.neon.tech connection snippet to the Connection Details widget. Instead of supplying a connection string when connecting with psql, you can use psql -h pg.neon.tech at the command line to launch a browser-based authentication flow.
• The notifications icon in the Neon Console page header is now highlighted when there's a new notification.
• Added RAM and vCPU alerts to the Neon Console to let you know when you're getting close to your plan limits.
• We deprecated the Neon CLI branches set-primary command, which is now replaced by the branches set-default command. This is a follow-up change associated with the renaming of "primary branches" to "default branches" that we implemented recently and announced in the June 21, 2024 changelog. Support for the branches set-primary command will be removed in a future release.
• For Free Tier users with access to shared projects, clicking an Upgrade Plan link within the shared project now displays a modal directing the shared project user to contact the project owner.
• The Neon CLI set-context command no longer saves the Neon branch ID to the context file. Branch IDs defined in existing context files remain supported for backward compatibility.
• Fixed an issue in the Neon CLI that caused a branch_id configured in a context file (created with the Neon CLI set-context command) to be used when an unrelated project ID was specified explicitly in a Neon CLI command.
• Fixed an issue that prevented creating a new branch in the Neon Console using a Safari browser when selecting a specific date and time as the branch creation point. The issue resulted in an Invalid Date error.
• Fixed an issue in the Neon Console that caused the history retention setting for a shared project to differ from the project owner's history retention setting.
• Fixed an issue in the Neon Vercel Integration to better handle errors reported for variables set by the integration that were already configured in Vercel. The issue caused preview deployment failures.
• Fixed an issue on the RAM and CPU charts on the Monitoring page in the Neon Console. The vertical axis scale was not displayed properly.
• For Free Tier accounts, we added a Data transfer usage metric to the Resources remaining widget on the Project Dashboard. The Neon Free Tier has a 5 GB per month data transfer allowance.
• Fixed an issue that caused an incorrect connection count limit to be displayed in a usage alert when a compute was in a suspended state.

The next act for the Neon platform

The Neon Product Team spent this week mapping the future state of our platform, focused on shipping faster with Postgres, and what it takes to get there.

We're excited about the big changes coming. While we want to keep some surprises under wraps, we'd like to share a few details here to let you know what to expect, and get any feedback you'd like to offer:

• Full-stack developer workflows — We're building end-to-end developer workflows focused on your database needs. Things like data and schema migrations, CI/CD integrations, and more.
• Complex data workflows — We're also building workflows to handle the more complex needs of managing data across multiple environments. Migrations, data anonymization, and staging deployments are a few examples. If you have ideas on what you'd like to see in these workflows, let us know on Discord.
• Integrated developer applications — We're making plans to solve other hard problems in App DevX, which we'll share when the time is right. Stay tuned.

Join the Neon Early Access Program to be among the first to try these Neon features as they come online.

Finer-grained history configuration

We've introduced finer-grained history retention settings for your Neon project. Neon retains a detailed history of changes for all branches, enabling features like point-in-time restore and time travel connections. However, this history also adds to storage usage. To give you greater control, you can now select from a broader range of preset retention periods down to the hour or set a custom value.

For more information about history retention and the features it supports, see Branch reset and restore.

Manage your billing info in the Neon Console

You can now update your billing information directly from the Billing page in the Neon Console. This includes details like your company name, billing address, and tax ID fields if applicable to your country or region. Previously, updating billing information required opening a support ticket.

Support for pgvector 0.7.2

Neon now supports pgvector version 0.7.2.

For the official list of updates, refer to the pgvector changelog.

If you installed this extension previously and want to upgrade to the latest version, please refer to Update an extension version for instructions.

Fixes & improvements

• Each Neon project is initially created with a "root" branch. Previously, this branch was designated as "primary" by default. To simplify our terminology, we've renamed this designation from "primary" to "default." Where you previously saw primary in relation to branches in the Neon Console, you will now see default. In line with this change, we've added default attributes to the Neon API. These will eventually replace the deprecated primary attributes in response bodies for endpoints like Get branches and Get branch details. Additionally, we've introduced a new Set branch as default endpoint, which will replace the deprecated Set branch as primary endpoint. The deprecated attributes and endpoint will be removed in a future release.
• Minimum autosuspend delay settings are now applied on a plan downgrade. Previously, the minimum allowable settings were not changed when downgrading from one Neon plan to another. For example, when downgrading from the Scale plan (with a minimum autosuspend delay of 1 minute) to the Launch plan, the minimum delay now automatically adjusts to 5 minutes, the default for the Launch plan.
• For Free Tier users, the Usage widget on the Neon Project Dashboard has been renamed to Resources remaining. This widget now displays your remaining storage, compute time, and branch allowances for the current billing period, providing a quick overview of your available resources.
• We fixed an issue in the Neon console where role names containing emoji characters were not displayed correctly. But maybe we shouldn't encourage this. 😅

Improved automation with Schema Diff in the CLI

You can now integrate the Neon CLI’s schema-diff feature into your CI/CD pipelines, letting you compare schemas between branches at any point in their history — useful for making sure that only the intended schema changes are promoted, maintaining consistent and controlled deployments.

Get started by using the command in your terminal:

neonctl branches schema-diff [base-branch] [compare-source[@(timestamp|lsn)]]

For example, this command compares the current schema state between the main branch and the development branch dev/alex:

neonctl branches schema-diff main dev/alex

Sample output of the schema-diff command might look like this:

--- Database: sales	(Branch: br-long-forest-a5glnuu4)
+++ Database: sales	(Branch: br-lucky-shape-a5fgfymm)
@@ -26,9 +26,10 @@

CREATE TABLE public.product (
    id integer NOT NULL,
    name text NOT NULL,
-    price numeric NOT NULL
+    price numeric NOT NULL,
+    description text NOT NULL
);

This diff shows that a new column description has been added to the product table in the dev/alex branch (br-lucky-shape-a5fgfymm) compared to main (br-long-forest-a5glnuu4).

For more detailed usage and options, see:

• Schema-diff in Neon CLI commands — branches
• Schema diff feature documentation
• Schema diff tutorial

Computes, roles, and databases moved to branch pages in the Neon Console

You can now find your branch's computes, roles, and databases on the branch page they belong to. This update better reflects the relationship of these objects to their specific branches in a Neon project.

With this change, we also moved the compute endpoint delete option to the Edit compute endpoint drawer, which you can access by clicking Edit on the Computes tab.

For more information about how objects in a Neon project are organized and related, see Overview of the Neon object hierarchy.

Support for pgvector 0.7.1

Neon now supports pgvector version 0.7.1. This new version improves the performance of on-disk HNSW index builds.

For the official list of updates, refer to the pgvector changelog.

If you installed this extension previously and want to upgrade to the latest version, please refer to Update an extension version for instructions.

Integration with Outerbase

We are excited to announce that the Outerbase integration for Neon is now publicly available.

This integration enables you to instantly connect your Neon Postgres database to Outerbase’s Data Studio and invite your team members to view, edit, query, and visualize your data.

Outerbase’s AI integration takes this a step further by helping users perform complex SQL tasks using natural language, making data manipulation accessible even to those without advanced SQL knowledge.

Outerbase's' data visualization tools help you create concise and beautiful charts and dashboards, making it easier to present and interpret data.

To learn how to connect Outerbase to your Neon project, check out this guide.

Fixes & improvements

• The Neon CLI now supports a --no-color global option, which you can use to decolorize CLI command output when using Neon CLI commands in your CI/CD pipelines.
• Fixed an issue with the dynamic rate limiter at the Neon Proxy that caused excessive CPU consumption and prevented new connections from being accepted.
• Added a Source column to the Branches widget on the Project Dashboard, which shows icons that indicate the creation source for the branch. For example, you are now able to see if the branch was created in Neon, via the Neon Vercel Integration, or through our Hasura integration.
• Added missing units of measure to the legends for several charts on the Neon Monitoring page in the Neon Console.
• Updated the Restore branch modal to include timezone information alongside the date and time of the selected restore point, providing clearer context for restore operations.

Create a Postgres database in seconds at pg.new

First, there was docs.new for instantly creating Google Docs. Then, repo.new made adding new GitHub repositories a breeze. Now, meet pg.new — your gateway to spinning up new Postgres databases in seconds. Simply visit pg.new and you'll be taken straight to the Create project page in the Neon Console, where you can set up your new Neon Postgres project.

Fixes & improvements

• Added your current timezone to the Restore branch confirmation page, to make it a little easier to understand the timestamp you are restoring to.
• Scale plan users can now view database metrics for the past 14 days on the Monitoring page in the Neon Console. To try it out, go to the Monitoring page and select the Last 14 days item from the Other menu. Previously, metrics could only be viewed for the past 7 days.
• The Database size chart on the Monitoring page in the Neon Console now displays size information for up to 10 databases.
• Adjusted the functioning of the Create support ticket modal in the Neon Console to avoid automatically selecting Branch and Compute field values when opening the modal.
• Fixed an issue that prevented the Autosuspend delay option from being displayed on the Edit compute endpoint drawer in shared projects.
• After the next time you log in to Neon Console, navigating to neon.tech will automatically route you to console.neon.tech.

What's new in docs?

We're excited to announce the addition of new Getting Started documentation. If you're new to Neon or want to explore its full range of features, start with these comprehensive guides:

• Playing with Neon
• Connect Neon to your stack
• Branching workflows
• Getting ready for production

In addition, we've released new Express and Reflex framework quickstarts:

• Connect an Express application to Neon
• Build a Python App with Reflex and Neon