What is Neon Serverless Postgres?

Neon is a serverless Postgres platform that separates compute and storage, offering autoscaling, branching, instant restore, and scale-to-zero while staying Postgres-compatible.

Which libraries should I use for authentication and data API?

Use @neondatabase/auth for authentication and @neondatabase/neon-js for the PostgREST-style Data API.

How do I start with Neon CLI and Platform APIs?

Install the Neon CLI, run neon init to bootstrap, and use the Neon Platform API/SDKs to manage resources programmatically.

neon-postgres

Scanned

npx machina-cli add skill VictrixTech/agent-factory-template/neon-postgres --openclaw

Files (1)

SKILL.md

4.2 KB

Neon Serverless Postgres

Neon is a serverless Postgres platform that separates compute and storage to offer autoscaling, branching, instant restore, and scale-to-zero. It's fully compatible with Postgres and works with any language, framework, or ORM that supports Postgres.

Neon Documentation

Always reference the Neon documentation before making Neon-related claims. The documentation is the source of truth for all Neon-related information.

Below you'll find a list of resources organized by area of concern. This is meant to support you find the right documentation pages to fetch and add a bit of additional context.

You can use the curl commands to fetch the documentation page as markdown:

Documentation:

# Get list of all Neon docs
curl https://neon.com/llms.txt

# Fetch any doc page as markdown
curl -H "Accept: text/markdown" https://neon.com/docs/<path>

Don't guess docs pages. Use the llms.txt index to find the relevant URL or follow the links in the resources below.

Overview of Resources

Reference the appropriate resource file based on the user's needs:

Core Guides

Area	Resource	When to Use
What is Neon	`references/what-is-neon.md`	Understanding Neon concepts, architecture, core resources
Referencing Docs	`references/referencing-docs.md`	Looking up official documentation, verifying information
Features	`references/features.md`	Branching, autoscaling, scale-to-zero, instant restore
Getting Started	`references/getting-started.md`	Setting up a project, connection strings, dependencies, schema
Connection Methods	`references/connection-methods.md`	Choosing drivers based on platform and runtime
Developer Tools	`references/devtools.md`	VSCode extension, MCP server, Neon CLI (`neon init`)

Database Drivers & ORMs

HTTP/WebSocket queries for serverless/edge functions.

Area	Resource	When to Use
Serverless Driver	`references/neon-serverless.md`	`@neondatabase/serverless` - HTTP/WebSocket queries
Drizzle ORM	`references/neon-drizzle.md`	Drizzle ORM integration with Neon

Auth & Data API SDKs

Authentication and PostgREST-style data API for Neon.

Area	Resource	When to Use
Neon Auth	`references/neon-auth.md`	`@neondatabase/auth` - Authentication only
Neon JS SDK	`references/neon-js.md`	`@neondatabase/neon-js` - Auth + Data API (PostgREST-style queries)

Neon Platform API & CLI

Managing Neon resources programmatically via REST API, SDKs, or CLI.

Area	Resource	When to Use
Platform API Overview	`references/neon-platform-api.md`	Managing Neon resources via REST API
Neon CLI	`references/neon-cli.md`	Terminal workflows, scripts, CI/CD pipelines
TypeScript SDK	`references/neon-typescript-sdk.md`	`@neondatabase/api-client`
Python SDK	`references/neon-python-sdk.md`	`neon-api` package

Source

git clone https://github.com/VictrixTech/agent-factory-template/blob/main/.cursor/skills/neon-postgres/SKILL.mdView on GitHub

Overview

This skill provides practical guidance for working with Neon Serverless Postgres—from getting started and local development to selecting connection methods and using Neon features. It covers authentication with @neondatabase/auth, data API access via @neondatabase/neon-js, and tooling like the Neon CLI and Platform API/SDKs. Use this skill to accelerate Neon adoption and build robust, scalable Postgres-backed apps.

How This Skill Works

Neon separates compute and storage to enable autoscaling, branching, and instant restore while remaining Postgres-compatible. Practically, you install the Neon CLI, create a Neon database, and connect from your app using a chosen driver or Neon JS data API depending on needs. The guidance integrates the auth and data API libraries with Neon platform tooling for end-to-end workflows.

When to Use It

Bootstrapping a Neon project and obtaining a connection string for development
Developing locally with Neon and testing without heavy infra
Choosing a connection method based on runtime (HTTP/WS, serverless, or ORM)
Implementing authentication and PostgREST-style data API with neon-auth and neon-js
Automating resource management with Neon CLI and Platform API/SDKs

Quick Start

Step 1: Install Neon CLI and run neon init to bootstrap your project
Step 2: Create a Neon database, retrieve the connection string, and install a driver or Neon JS
Step 3: Connect, authenticate, and run a simple query using your chosen method (driver or Neon JS data API)

Best Practices

Always reference Neon docs as the source of truth before making claims or decisions
Use the Neon CLI for local development and for provisioning Neon resources
Select a connection method based on runtime, performance needs, and network constraints
Leverage @neondatabase/auth for authentication and @neondatabase/neon-js for the Data API
Test Neon features (autoscale, branching, scale-to-zero, instant restore) in a sandbox before production

Example Use Cases

Bootstrap a new app and connect using a standard Postgres driver
Use Neon JS to interact with a PostgREST-style Data API for data access
Create a development branch of a Neon database to isolate feature work
Run a serverless workload that scales to zero with Neon
Automate provisioning and teardown with the Neon Platform API/SDKs

Frequently Asked Questions

Add this skill to your agents