March 2025 Summaries

Vercel's V0 has recently introduced integrations for Neon, Supabase, and Upstash, allowing users to add persistent storage and deploy full-stack applications in minutes. However, detailed prompting is crucial to guide V0 effectively. To illustrate this, the author created a time-clock application with a clear scope and incremental development, showcasing how well-defined prompts significantly enhance outcomes. The author emphasizes the importance of providing context, outlining project goals upfront, and guiding V0 through informed prompts to avoid misinterpretation. By doing so, users can rapidly prototype and deploy full-stack applications without unnecessary complexity. The integration with Neon Postgres is particularly useful for iterative development, offering a serverless experience that scales effortlessly with project needs. To set up Neon Postgres with V0, users follow the setup wizard and may need to adjust the generated code to meet their specific requirements. Effective issue handling involves reviewing and revising prompts to minimize scope creep and prevent unintended issues. By following these best practices, users can maximize productivity with V0 and Neon Postgres.

Vercel's v0 integration with Neon Postgres offers a streamlined approach to rapidly prototype and deploy full-stack applications by providing persistent storage and simplifying database management. The integration, part of v0's recent evolution beyond frontend code generation, facilitates the creation of server-side components, handling of environment variables, and connections with APIs and external data sources. Detailed prompting is essential for guiding v0 effectively, allowing developers to clearly define project goals and tasks to avoid misinterpretation and unnecessary complexity. By using mock data and progressively implementing database connectivity, developers can maintain simplicity and focus, reducing the risk of scope creep. The Neon Postgres integration, with its serverless and scalable nature, complements v0 by offering an easy setup and efficient database connection management, making it ideal for iterative development. The text also emphasizes the importance of reviewing and refining prompts to address AI hallucinations and ensure the generated solutions remain efficient and within the intended scope.

Neon's instant restore feature, or PITR, is a unique implementation that gives customers peace of mind by allowing them to recover their entire database instantly to any point in time. This is made possible by Neon's separation of compute and storage architecture, which uses a control plane to manage cloud resources across both layers. The storage system consists of three key components: WAL safekeepers, pageservers, and cloud object storage. Safekeepers capture all data changes and use a Paxos-based consensus mechanism to ensure durability, while pageservers process incoming WAL data and store database pages in a format optimized for fast access. Object storage preserves all history long-term. When a user triggers PITR, Neon creates a new branch of the database at a specific Log Sequence Number (LSN), instantly making the restored state available. This process is instant and requires no data copying, eliminating hours of restore time and expensive compute operations.

pg_search, a high-performance full-text search extension, is now available on Neon, making it easier to build fast and full-text search experiences with Postgres. By using pg_search, developers can skip the complexity of generating and inserting embeddings, resulting in blazing-fast search performance up to 200x faster than the original AI-powered search implementation. The demo uses Vercel's Book Inventory template and replaces the AI-powered search with native PostgreSQL full-text search using pg_search. The results show significant performance gains, including optimized sorting, accelerated field search, and efficient AND search, making it an attractive option for developers looking to build fast and scalable search experiences with Postgres.

Neon's instant Point-in-Time Recovery (PITR) feature stands out for its ability to quickly and efficiently restore multi-terabyte databases to any past state without data copying, leveraging a unique storage architecture. Unlike traditional systems like AWS RDS that require creating a new database instance and replaying transaction logs—a process that can be time-consuming and resource-intensive—Neon adopts a branch-based approach. This method utilizes a multi-tenant storage system with WAL safekeepers, pageservers, and cloud object storage, allowing for instant restores by creating a new database branch at a specific Log Sequence Number (LSN) without duplicating data. This architecture is characterized by the separation of compute and storage, where compute nodes operate without local persistence, and all data changes are streamed and managed through a highly available and durable storage layer. With this setup, Neon's PITR provides a faster, more scalable recovery option that is particularly advantageous for large-scale databases, offering significant time and cost savings.

You can migrate from Supabase Auth to Neon Auth with a simple three-step process. First, export your users from Supabase by running a SQL query that retrieves all users and their encrypted passwords. Then, set up your Neon Auth tables by selecting the "Setup Stack Auth" option in the Neon Auth menu. Finally, import your users into Neon Auth using the Stack Auth REST API to create new users with preserved password hashes. This process allows for secure, continuous authentication while maintaining data ownership.

The Neon serverless driver for JavaScript and TypeScript now has a more stable structure, with automated bundled types and a set of CI tests to catch regressions. The driver can carry SQL queries over HTTP and WebSockets, making it suitable for environments where raw TCP connections aren't available or low connection latencies are important. New features include tagged-template composability, which allows building up queries from smaller parts, and fixing a potential SQL-injection footgun by introducing a `query` function to safely pass in query and values as variables. Additionally, improvements have been made for inserting binary data over HTTP, speeding up the hex-encoding step using `TextDecoder`, `Uint32Array`, and bit-twiddling.

Migrating from Supabase Auth to Neon Auth involves a process that simplifies the management of user authentication by integrating it directly with a Postgres database, ensuring complete data ownership and simplifying application queries. The migration process is broken down into three main steps: exporting users and encrypted passwords from Supabase using a SQL query, setting up Neon Auth in the Neon project, and importing the user data into Neon Auth through the Stack Auth REST API. This process retains security by preserving the original bcrypt password hashes in Modular Crypt Format, allowing passwordless migration and continuity in user authentication. The users are stored in a neon_auth.users_sync table, which is managed by Neon Auth and should not be directly modified. The article highlights the efficiency of this migration process and encourages users on Supabase to explore Neon Auth by signing up for a free account.

Neon has officially released version 1.0.0 of its serverless driver, which facilitates SQL query execution over HTTP and WebSockets in environments where raw TCP connections are unavailable, such as V8 isolate-based serverless functions and web browsers. This milestone release features a refactored codebase for improved structure and stability, automatic type extraction, and comprehensive CI testing across various platforms like Node, Bun, Deno, and major browsers. Key enhancements include the introduction of tagged-template composability for safer query construction and the resolution of a SQL injection vulnerability that stemmed from improper query interpolation. Further, the update addresses performance and compatibility issues with inserting binary data via HTTP, although it remains more efficient to use WebSockets for large data transfers. These changes aim to enhance security, performance, and ease of use for developers working with Neon's serverless driver.

Windsurf is an IDE that not only writes code but also provisions, migrates, and queries Postgres databases. It integrates with Neon MCP server to allow agents to interact directly with the database, enabling developers to build applications without writing a line of code. The process involves setting up Neon's MCP server in Windsurf and configuring it with an API key, then using the agent to create a Todo application or add features like priority labels. With this integration, developers can automate database management tasks, ensuring consistency and reducing manual work.

Windsurf, in conjunction with Neon MCP, offers a streamlined approach to agent-driven database interactions, allowing developers to manage databases with ease. By leveraging the Model Context Protocol (MCP), Windsurf acts as an MCP client that securely interacts with Neon, an MCP server, to handle tasks such as database provisioning, migrations, and querying without requiring manual code writing. The process involves setting up Neon MCP in Windsurf, configuring the server through an API key, and using Cascade to build a Next.js Todo application that integrates seamlessly with Neon Postgres. Cascade efficiently breaks down tasks like project initialization, schema creation, and API generation, ensuring a fully functional application is developed swiftly. Additionally, Cascade's capability to enhance applications by adding features, such as a priority label to a Todo list, demonstrates its potential to generate clean and thoughtful schema migrations. This integration not only maintains consistency between the application and database but also reduces the need for manual intervention, making database management more accessible to developers.

Azure AI Agent Service is a fully managed solution that enables developers to create, deploy, and scale AI agents without worrying about infrastructure. The service handles the entire tool-calling process by executing the model based on given instructions, automatically calling required tools, and delivering results back to users. Azure AI Agent Service supports various GenAI frameworks, including Neon, which provides features such as smart microservices, built-in tools, seamless API integration, fully managed solutions, database branching, and full programmatic control over database creation, updates, and deletions. Neon's database branching feature allows developers to create separate environments for testing without affecting production, experiment with AI models and data without risk, and quickly restore previous versions of the database. The service also provides a knowledge tool for vector storage and semantic search in Azure AI Agent.

Azure AI Agent Service, part of Azure AI Foundry, enables the creation of AI agents that can automate workflows and perform tasks without requiring extensive coding or using Azure AI SDKs. These agents integrate with Neon, a serverless Postgres platform, for efficient database management and semantic search capabilities. Utilizing frameworks like LangChain and Semantic Kernel, Azure AI agents can interact with real-world data through Azure OpenAI models and external tools, thanks to seamless API integration. The Neon platform's features, such as database branching and vector storage, enhance the agents' ability to provide context-aware responses and manage databases dynamically. By employing the Azure AI Agent Service with Neon, developers can deploy AI agents to create, configure, and manage databases through simple commands, streamlining the process and eliminating the need for manual infrastructure management. The article exemplifies this process by demonstrating how an AI agent can be configured to manage Neon databases, aiming to improve efficiency and accuracy in database-related tasks.

I've summarized the key points of the text for you. The author compared two AI-powered IDEs, Windsurf and Cursor, which are forks of VSCode and use Anthropic's Claude model under the hood. Both editors offer similar features, including tab completions, multi-file refactoring, agent-based workflows, and context management. However, the author found that Cursor excelled in tab completions, offering tighter control and better confidence in the AI coding workflow. On the other hand, Windsurf offered better automatic context indexing, leading to a more "magical" agentic workflow. The author concludes that both IDEs significantly boosted their productivity when porting a project, but with different strengths.

Nodecraft, a game server hosting platform, has transitioned its backend to a fully serverless architecture built on Cloudflare Workers and Neon. This shift eliminates the operational overhead of managing Postgres while improving multi-region performance and scalability. Nodecraft now uses Cloudflare Workers for game configuration logic at the edge, reducing latency for players across multiple regions, Neon as the central database storing core user data, Rulesmith to dynamically build game server UIs based on stored configurations in Neon, and Hyperdrive to cache game configuration data, making database queries super fast in Neon. The company has also taken advantage of Neon's branching feature, which allows them to create fully isolated copies of their database in seconds, saving time for development and live demos. By combining these tools, Nodecraft has transformed the way they manage infrastructure, improving performance and scalability while reducing operational overhead.

Nodecraft, a game server hosting platform, has transitioned from traditional infrastructure to a serverless architecture using Cloudflare Workers and Neon to enhance scalability and performance for its multiplayer game servers. By adopting this architecture, Nodecraft has reduced latency and operational overhead, allowing for efficient global operations and easy database management with Postgres in a serverless setup. The use of Hyperdrive for caching has further optimized database query times, improving responsiveness. Additionally, Neon’s branching feature enables quick development and isolated testing environments, providing flexibility for development and live demonstrations. This transformation allows Nodecraft to better meet the unique configuration needs of over 30 different games, catering to a diverse player base worldwide.

AI-powered integrated development environments (IDEs) like Windsurf and Cursor, both forks of VSCode using Anthropic’s Claude model, have emerged as notable tools, offering features such as advanced tab completions, multi-file refactoring, and context management. While Windsurf excels in automatic context indexing, providing a seamless agentic workflow, Cursor stands out with its impressive tab completions and flexible context management, enabling developers to define custom rules and documentation. Both IDEs support agentic workflows with features like Cascade and Composer, which automate tasks and generate comprehensive tests, although they face challenges with complex coding scenarios. The author’s experience developing the Neon Python driver highlights the productivity gains achieved with these IDEs, particularly in porting SQL-over-HTTP drivers to Python for serverless functions. Despite their different strengths, both Cursor and Windsurf significantly enhance coding efficiency and offer new ways to leverage Neon in Python applications.

pg_search is a high-performance full-text search extension for Postgres, bringing Elasticsearch-grade features inside Postgres. It addresses gaps in speed, ranking quality, and advanced search capabilities of native Postgres' full-text search (FTS) via tsvector and tsquery, including issues with indexing, ranking, and faceted search. pg_search is an extension written in Rust using the pgrx framework, without external dependencies or services, allowing standard SQL syntax interaction. It introduces a custom inverted index (BM25 index) to efficiently store tokens and document references, optimizing indexing for speed and enabling advanced features like prefix search, typo tolerance, and faceted searches. pg_search consistently outperforms native Postgres in benchmarking, delivering up to 1,000x faster performance for some queries. It is now available on Neon databases in AWS regions running Postgres 17, with installation instructions provided.

Neon offers a solution for B2B SaaS companies operating across multiple regions, providing better compliance and security, consistent performance, and easier management compared to traditional multi-tenant setups in AWS RDS. With Neon's one-project-per-customer model, each customer operates in their own dedicated environment, isolating data and ensuring regulatory requirements are met. This approach also eliminates noisy neighbor bottlenecks, allows for straightforward scaling globally, and provides fine-tuned compute scaling for cost efficiency. Additionally, Neon offers automated project and database provisioning, enforcing per-project resource quotas, and fleet-wide monitoring & usage tracking.

Neon has integrated pg_search, a high-performance full-text search extension written in Rust, to enhance its PostgreSQL capabilities, offering Elasticsearch-level speed for search-heavy applications and large datasets. This extension addresses the limitations of native PostgreSQL full-text search by providing advanced features such as the BM25 algorithm for better relevance ranking, typo tolerance, prefix search, and faceted search capabilities, without requiring external dependencies or services. The integration allows for real-time updates and immediate consistency in search results, significantly improving search performance, as demonstrated by benchmarks showing up to 1,000x faster query execution compared to a tuned Postgres instance using GIN indexes. The extension is fully integrated with PostgreSQL's MVCC system, ensuring concurrent access and immediate searchability of new data, making it particularly suitable for live applications.

Neon offers a solution for B2B SaaS companies needing HIPAA compliance, multi-tenancy management, and scaling across regions by providing a unique "one-project-per-customer" model. This approach contrasts with traditional shared database models, like AWS RDS, by giving each customer a dedicated Postgres instance, ensuring better compliance, security, performance, and scalability. Neon's model eliminates issues like compliance risks, noisy neighbor bottlenecks, and complex database management by isolating customer data into separate projects, allowing for easy global scaling and per-customer data management. The Neon API facilitates automated project provisioning, resource quota enforcement, and real-time monitoring, making the management of thousands of projects efficient and cost-effective compared to the traditional RDS setup, which often faces challenges with manual scaling, compliance, and performance unpredictability.

Marco D'Alia, a software architect behind RagRabbit, built the tool to simplify his own workflow by combining multiple systems for web scraping, vector search, and AI responses into one single, open-source toolkit. RagRabbit crawls websites, converts pages to Markdown, generates embeddings with Postgres via pgVector, provides AI Q&A using OpenAI or Claude, and offers an MCP server for read-only doc chunks directly into IDEs or chat apps. The tool accommodates different authentication setups, including user/password, GitHub OAuth, and magic links, and can be deployed on Vercel's Neon with a single click, taking advantage of its serverless scaling and Postgres features like full-text search.

RagRabbit, developed by software architect Marco D’Alia, is an open-source tool designed to simplify the process of Retrieval-Augmented Generation (RAG) by using Postgres as a comprehensive solution for web scraping, vector search, and AI responses. The tool crawls websites to convert pages into Markdown format, generates vector embeddings using the pgVector extension in Postgres, and facilitates AI-powered Q&A by conducting similarity searches within the database. It supports authentication methods such as user/password, GitHub OAuth, or magic links, and ensures secure access to indexed content. By leveraging Neon for its Postgres database, RagRabbit benefits from instant provisioning, serverless scaling, and full-text search capabilities, eliminating the need for a separate vector database. The seamless integration with Vercel allows for a one-click deployment, making it easy for users to implement without additional infrastructure. RagRabbit aims to provide a streamlined, low-cost solution capable of scaling according to demand, with a focus on maintaining simplicity and efficiency in deployment and maintenance.

The text discusses the challenges of making changes to a database schema, particularly when adding unique constraints or enforcing NOT NULL values. These operations can lead to unexpected locking issues, causing downtime and outages. The article highlights the importance of caution and expertise in managing database schema migrations. It introduces two tools, Atlas and Neon, which can help mitigate these risks. Atlas provides static analysis to catch risky migrations before they reach production, while Neon enables realistic pre-deployment simulations using database branching. By integrating these tools into a CI/CD pipeline, developers can prevent database locks from taking down their application, embracing schema migrations with confidence.

Schema migrations in PostgreSQL can lead to database locks and potential downtime if not handled carefully, especially when adding constraints like UNIQUE or NOT NULL that require full table scans and ACCESS EXCLUSIVE locks. To avoid such issues, developers can adopt best practices like creating indexes concurrently and validating constraints in stages. However, these practices alone may not suffice, necessitating the use of advanced tools such as Atlas and Neon. Atlas, a schema management tool, provides static analysis to catch risky migrations before they reach production, while Neon offers database branching for realistic pre-deployment simulations. By integrating Atlas into CI/CD pipelines and using Neon’s branching capabilities, teams can effectively prevent database locks and ensure smoother migrations, ultimately fostering a more confident approach to database schema changes.

Neon has completed its HIPAA compliance audit, adding to its security achievements: SOC 2 Type 2, ISO 27001, ISO 27701, GDPR, and CCPA. The Health Insurance Portability and Accountability Act (HIPAA) sets national security and privacy standards for handling Protected Health Information (PHI). By meeting these standards, healthcare organizations, SaaS platforms, and other regulated businesses can now store and process PHI confidently on Neon's platform, which protects PHI at every stage with encryption, access controls, incident response, audit logs, monitoring, employee training, third-party security, and customer responsibilities. HIPAA compliance isn't the finish line for Neon; it continues to improve its security to stay ahead of threats, upholding existing certifications and aligning with new requirements like PCI-DSS in Q2.

The author of this text explored using AI-driven synthetic data generation, specifically focusing on vibe coding, a method that skips boilerplate code and uses natural language to describe what is needed. The goal was to integrate synthetic data generation into the Twin workflows for improving Dev/Test workflows. To achieve this, the author used Anthropic's API, which takes a schema file as input and generates realistic data that aligns with the provided schema. The author experimented with two approaches: using AI only to generate data and using AI with faker.js to generate data. In both cases, the model struggled to maintain referential integrity, particularly when generating large amounts of data. The author plans to refine their prompt-writing skills and experiment with ways to help the model reason more effectively.

Paul Scanlon, a Technical Product Marketing Manager, explores the concept of "vibe coding" for AI-driven synthetic data generation, aiming to streamline development and testing workflows at Neon. Vibe coding involves using natural language to instruct AI, bypassing traditional coding details, which Scanlon sees as beneficial for creating synthetic data across various PostgreSQL databases. Despite initial challenges, such as maintaining referential integrity and managing model overloads, Scanlon experimented with both AI-only and hybrid approaches using models like Anthropic and GPT-4.5, integrating tools like faker.js to generate SQL INSERT statements. The process highlighted the complexities of maintaining data integrity at scale, suggesting that refining prompt-writing and incorporating more explicit instructions could enhance AI performance. Scanlon plans to further refine his techniques and explore educational resources to improve the outcomes of AI-driven data generation.

Neon has achieved HIPAA compliance, allowing it to securely store and process Protected Health Information (PHI), adding to its existing security certifications such as SOC 2 Type 2, ISO 27001, ISO 27701, GDPR, and CCPA. To ensure HIPAA compliance, Neon employs encryption, access controls, continuous monitoring, and an incident response system that includes breach notification within five business days. The platform provides mandatory HIPAA training for employees and requires third-party subcontractors to meet HIPAA standards, while customers must configure their systems to comply with HIPAA guidelines. Neon's commitment to data security is ongoing, with plans to achieve PCI-DSS compliance in the near future to further enhance its security measures for enterprise customers.

The Model Context Protocol (MCP) is a rapidly gaining protocol that allows external tools, services, and data sources to extend Large Language Model (LLM) capabilities. By building a standalone MCP server, developers can expose their smart home control utilities to any existing LLM agents, making the approach more scalable and reusable across multiple LLM apps and agents. This contrasts with function calling, which requires additional abstraction layers for scalability. MCP extends LLM function calling by separating function definitions from LLM applications, allowing tool builders to create standardized interfaces (MCP servers) for their tools and services. The protocol provides a higher level of abstraction than function calling, enabling seamless integration between LLMs and external tools.

The Model Context Protocol (MCP) is gaining popularity as a method to enhance Large Language Models (LLMs) by integrating them with external tools, services, and data sources, creating a more scalable and reusable system than traditional LLM function calling. Unlike the function calling approach, where functions are defined and executed within each LLM application, MCP establishes standalone servers that expose functionalities to multiple LLM agents, allowing for a standardized interface that can be reused across applications. This approach is exemplified by the use of an MCP server to control smart home devices through Home Assistant, demonstrating how MCP can act as a bridge between AI applications and third-party services. MCP provides a higher level of abstraction by separating function definitions from LLM applications, enabling tool builders to create MCP servers that any MCP-compatible LLM can access, thus streamlining the integration process and avoiding the need for redundant implementations.

Your traditional database is reliable for production workloads but struggles with the developer experience, including issues with shared environments, schema changes, and resource management. Neon is designed to solve these challenges with features such as serverless architecture, branching for development and testing, integration and compatibility, provisioning environments, and automatic nightly dump and restore processes. The Dev/Test workflow involves creating isolated copies of production or staging databases, known as Neon Twins, which can be used by developers without impacting the stability or performance of the production environment. A Neon Twin is a full or partial copy of the production or staging database, providing developers with safe spaces to build, test, and iterate with real production data and schema. GitHub Actions power both workflows and can be configured to run on a recurring schedule or trigger specific events, while self-hosted runners provide control over the environment, region, IP address, and execution time.

Neon offers an innovative solution for development and testing environments by providing a system called Neon Twin, which allows developers to create isolated, sandboxed environments that closely mirror production without impacting its stability. Neon is designed to address common challenges in traditional databases, such as shared environments and risky schema changes, by introducing features like serverless architecture with autoscaling, branching for development and testing, and integration with the latest Postgres versions. These capabilities enable teams to streamline workflows, speed up development, and maintain productivity without the complexity and costs associated with traditional environments. The Neon Twin workflow includes a Full Twin, which is an exact copy of a production database, and a Partial Twin, which includes only a subset of data, both of which can be managed through GitHub Actions. While there are limitations, such as the default timeout of GitHub Actions, solutions like self-hosted runners and Slack notifications are provided to enhance functionality and communication.

We all have experienced the stress of a production database going down, resulting in high-stress situations with downtime. Traditional Postgres restores involve restoring from snapshots or backups and replaying WAL, a time-consuming process especially for large datasets. Neon's Instant Restore leverages its copy-on-write branching approach to make near-instant recovery possible by creating a new branch from the exact point in time before the failure and seamlessly redirecting the app to this restored branch in under a second. This approach allows for fast recovery even with multi-terabyte databases, making it a potential game-changer for database recovery mechanisms in services like Amazon RDS.

Neon offers a near-instant recovery solution for Postgres databases through its innovative Instant Restore feature, which leverages copy-on-write branching to rapidly restore databases without the need for traditional snapshot or backup recovery methods. By utilizing Neon's architecture, which references shared storage and records only changes, the recovery process is significantly expedited, even for databases as large as multi-terabytes. The Outage Simulator demonstrates this capability by simulating a database failure in a web app and showcasing how the app can be swiftly brought back online by creating a new branch from the exact point in time before the failure. This approach sets a new standard for database recovery by reducing downtime and operational complexity, offering a faster alternative to traditional methods used by services like Amazon RDS.

The developer created a VSCode extension that allows users to order food from Grubhub using the platform's API. The extension uses a Language Model (LLM) tool to generate parameters for the API calls, and it leverages Postman Interceptor to intercept and manipulate requests. After reverse-engineering the Grubhub API, the developer found that only 5 routes are necessary to place an order: `POST /carts`, `POST /carts/{cart_id}/lines`, `PUT /carts/{cart_id}/delivery_info`, `POST /carts/{cart_id}/payments`, and `POST /carts/{cart_id}/checkout`. The extension is built using TypeScript and requires the VSCode LanguageModelTool class to invoke functions. To simplify API workflows, the developer implemented a system that cleans and simplifies the API for AI agents to use effectively. The extension can be installed in VSCode, and users can input their bearer token and POINT values to complete the ordering process.

In a humorous exploration of tech innovation, a developer team created a VSCode chat extension designed to order cheeseburgers via Grubhub, despite the absence of a public API for food ordering. The process involved reverse engineering Grubhub's API using Chrome Dev Tools and Postman Interceptor to intercept requests, which led to the accidental ordering of a cheeseburger. The project illustrates the steps of building a VSCode extension, including using TypeScript to access APIs and utilizing JSON schemas for function calling. The blog post highlights the challenges of making APIs user-friendly for AI agents and underscores the importance of workflows in creating a smooth user experience. The developers acknowledge the complexity of maintaining such an extension and suggest using tools like Layer to simplify API interactions for AI agents.

The Neon Developer Creator Program is a support initiative for developers creating content related to Postgres and other developer tools. Members receive benefits such as a free Scale account, early access to new features, sponsored speaking opportunities, and growth collaborations with Neon. The program aims to help creators build their skills and share knowledge with the community. To apply, simply fill out a short form on the Neon website. While there isn't an official nomination process, interested individuals can be shared the link with them.

Neon has shipped its Private Networking feature, which allows users to connect their Neon database to AWS PrivateLink with zero exposure to the internet. This makes it easier for customers on Business and Enterprise plans to meet security and compliance requirements while still enjoying Neon's developer experience. The feature uses an isolated proxy service within the user's AWS environment to securely route traffic to the Neon database, eliminating the need for code changes or direct internet access. Setting up Private Networking is straightforward and self-serve, with step-by-step instructions available on the Neon website. The feature is now available to all customers on Business and Enterprise plans, offering a secure and private endpoint for connecting to the Neon database.

AWS PrivateLink for Neon Databases offers a secure way to connect Neon databases to applications within AWS's private network, eliminating exposure to the public internet. This feature, available in Neon's Business and Enterprise plans, is designed to meet security and compliance requirements by allowing connections to remain within AWS's internal network. By integrating with AWS PrivateLink, Neon provides a private endpoint service, enabling applications to route database queries securely without requiring code changes, thereby maintaining the same database connection string. The setup is user-friendly, involving the creation of a VPC endpoint linked to Neon's service, facilitating a seamless and secure connection for applications running in AWS environments.

At Neon, speed and security are integrated into every layer of their platform. The company has launched a private bug bounty program on HackerOne three months ago to identify vulnerabilities and strengthen defenses. Now, they're taking the next step by opening their bug bounty program to the global security research community, making it public. This move is aimed at tapping into diverse expertise to uncover vulnerabilities faster and continuously raise the bar for security. With Neon's growing user base and business reliance on their platform, now is the time to scale their security efforts. The company has streamlined the scope of their bug bounty program to focus on web applications and APIs, with rewards ranging from $150 to $3000 depending on severity and impact. Researchers can sign up like real users to explore the platform and test different flows, and Neon values the hard work of hackers who help keep their platform secure.

Neon, a company focused on database technology, has announced the public launch of its bug bounty program on HackerOne, building on the success of its private program initiated three months prior. The move is aimed at enhancing security by inviting global security researchers to identify vulnerabilities in Neon's web applications and APIs. This initiative underscores Neon’s commitment to integrating security into its platform and involves offering financial rewards for identified issues, with bounties ranging from $150 to $3000 based on the severity and impact of the vulnerabilities discovered. By opening the program to a wider audience, Neon seeks to tap into diverse expertise to bolster its defenses and ensure a robust, resilient platform as its user base grows.