September 2024 Summaries

The @neondatabase/toolkit has been released on NPM to merge the existing packages @neondatabase/api-client and @neondatabase/serverless into a single, more accessible SDK for AI agents. This consolidation aims to improve the performance of AI agents by reducing their search space. Neon already offers unique features suitable for AI agents, but with this toolkit, they have streamlined the API to make it easier for these agents to consume. They plan to add more features and options in future updates. The team is also seeking feedback from users, particularly those building AI agents, to further improve the package.

Neon has introduced a new package on NPM called @neondatabase/toolkit, designed to simplify API interactions for AI agents by merging the existing @neondatabase/api-client and @neondatabase/serverless packages into a single SDK. This consolidation aims to make API consumption more efficient for AI agents by reducing the complexity of their search space, similar to how specialized software engineers perform better within their expertise. The toolkit allows for streamlined database operations with Postgres, providing a more accessible interface for creating, managing, and interacting with databases through JavaScript. Future updates will include features like branching and autoscaling, with the option for connections via HTTP, WebSockets, or TCP. The Neon team is actively seeking feedback from developers building AI agents to improve the package, highlighting its potential to unlock new use cases beyond AI.

Postgres 17 is now available on Neon, allowing users to quickly set up and test the new features of this latest version. Key improvements include simplified queries using MERGE with RETURNING, generating random integers with the improved random() function, querying JSON data with JSON_TABLE, reducing connection latency with sslnegotiation=direct, and gaining insights into memory usage via EXPLAIN. Neon users can upgrade to Postgres 17 by following a guide on upgrading their Postgres version.

Postgres 17 is now available on Neon, providing users with new features such as the enhanced MERGE command with RETURNING clause, which streamlines queries by allowing conditional insertions, updates, or deletions without multiple queries. The improved random() function now accepts range parameters for generating random integers within a specified range, useful for tasks like creating test data. Additionally, Postgres 17 introduces JSON_TABLE to transform JSON data into a relational format, simplifying JSON data manipulation. The new sslnegotiation=direct parameter reduces connection latency by skipping unnecessary SSL negotiation steps, enhancing connection speeds even on older Postgres versions. The EXPLAIN command has been upgraded to report memory usage during query planning, helping users identify resource-intensive queries. While minor version upgrades on Neon occur automatically, manual steps are required for major version upgrades, and users should check for extension support before upgrading to Postgres 17.

Many companies are wasting money on unused compute due to overprovisioned production databases and non-prod environments running up costs. A recent survey found that 63% of developers needed their allocated compute capacity for 8 hours a day or less, with traffic being much lower the rest of the time. Additionally, 56% of developers were using their dev/test instances for 4 hours per day or less. This translates into significant wasted money on unused resources. Neon is a managed Postgres provider that offers solutions to this problem by allowing users to pay only for the compute they're using through autoscaling and scale-to-zero functionality.

AWS RDS users often face inflated bills due to overprovisioned production databases and continuously running non-production environments, leading to substantial waste in computing resources. Many companies allocate more compute capacity than necessary to avoid performance issues, resulting in unused resources that drive costs up. A survey of developers revealed that a significant portion of production database capacity is only needed for a few hours daily, while non-production databases run continuously despite limited usage. This inefficiency can lead to thousands of dollars in unnecessary expenses each month. Neon, a managed Postgres provider, addresses this issue with a serverless platform that offers dynamic autoscaling for production databases and scale-to-zero functionality for non-production environments, ensuring that users only pay for the compute they actively use.

Local-first frameworks are gaining popularity as they put users' data first, allowing them to work offline and sync changes when connected again. These frameworks address the limitations of cloud applications that become unusable when the network fails. Key concepts like Conflict-Free Replicated Data Types (CRDTs) enable seamless merging of concurrent changes in collaborative documents without conflict. PouchDB is a JavaScript database designed for offline use and syncing with server-side databases, while ElectricSQL uses Postgres as the underlying data store to efficiently sync little subsets of data into connected local apps. Local-first approaches are changing how we think about data ownership and application architecture, making applications more resilient, privacy-respecting, and user-centric.

Local-first frameworks are gaining traction as they prioritize data ownership and usability by allowing applications to function offline and sync data when online, addressing the limitations of cloud-first models. The approach involves using technologies like Conflict-Free Replicated Data Types (CRDTs) and databases like PouchDB and ElectricSQL to ensure seamless data merging and syncing without relying solely on central servers. CRDTs enable real-time collaboration by allowing independent updates to data replicas that eventually converge to the same state, while PouchDB offers a document-based database that syncs with server-side databases, and ElectricSQL uses Postgres for efficient data syncing. These frameworks are part of a broader trend aiming to give users control over their data, enhancing privacy, user autonomy, and resilience against network failures, ultimately transforming the relationship between users and their data.

In recent years, there has been significant innovation in Node.js runtimes with the emergence of alternatives such as Deno and Bun. These new runtimes aim to address some of the issues faced by Node.js, including security concerns and complexity in package management. While Deno focuses on security-oriented features and modern JavaScript support, Bun prioritizes performance improvements and streamlined developer experience. Both runtimes offer built-in TypeScript support and are gaining traction among developers who appreciate their unique features. However, the choice of runtime ultimately depends on specific project requirements and priorities.

Innovations in JavaScript runtimes have expanded beyond Node.js to include contenders like Deno and Bun, each offering distinct advantages tailored to specific needs. Node.js, while popular for its ability to handle numerous connections with non-blocking I/O, faces criticism for security vulnerabilities, package management complexity, and build system intricacies. Deno, developed by Node.js creator Ryan Dahl, prioritizes security with sandboxed code execution, built-in TypeScript support, and reliance on standard modules, aiming to align more closely with browser JavaScript. It also offers additional infrastructure and deployment options, including Deno Deploy. Meanwhile, Bun focuses on performance, leveraging the JavaScriptCore engine for speed and offering streamlined configuration, runtime TypeScript transpilation, and enhanced APIs like Bun.file and SQLite. Although Bun is still young, its emphasis on efficiency and developer experience is drawing attention, particularly for high-performance projects. The choice between these runtimes depends on project requirements, with Node.js suiting long-term stability, Deno offering enhanced security, and Bun excelling in speed and developer convenience.

Replit has introduced Replit Agent, an AI Software Engineer that assists in creating full-stack applications. This tutorial guides users through the process of using Replit Agent to build a news app that scrapes data from Hacker News, stores it in a Postgres database, and displays it using Next.js front end. The key steps include signing up for Replit, enabling Replit Agent, starting a new project with a natural language prompt, approving the plan, watching the project build, customizing the scraper, setting up the Postgres database, creating the Next.js front end, deploying the app, and reviewing the results. The benefits of using Replit Agent include speed, simplicity, versatility, and end-to-end development capabilities.

Replit Agent is an AI-powered development tool designed to simplify the process of building full-stack applications by allowing developers to create, debug, and deploy apps using natural language prompts. This guide details how to use Replit Agent to create a news app that scrapes data from Hacker News, stores it in a Postgres database, and displays it using a front-end built with Next.js. The tool integrates with various third-party APIs and databases, offering an end-to-end development experience that includes building, testing, and deployment. Although still in early access and potentially subject to errors, Replit Agent provides a rapid prototyping environment that can significantly accelerate development by reducing complexity and time investment, making it accessible even to those with minimal coding expertise.

Neon is a Postgres service with a custom-built storage engine that separates compute from persistence, making it suitable for building multi-tenant, database-per-user applications. In this article, the focus is on designing an effective control plane to manage such systems at scale while maintaining operational efficiency and security. The Neon object hierarchy consists of projects, branches, and databases. When talking about database-per-user architectures in Neon, a project-per-user design is usually considered. A control plane is a crucial component for managing database-per-user systems. It extends beyond tools like the Neon console and `neonctl` to include other systems such as CI/CD, observability platforms, and schema migration frameworks. The control plane grows with an organization's system and its needs. The catalog database serves as a centralized hub for tracking and managing all Neon projects and databases. It is essential for effectively managing projects at scale by storing critical operational data such as schema version and customer billing status. Designing the catalog database schema involves linking tables, using appropriate data types, capturing critical operational data, indexing, and starting with the essentials while planning for extensions. The control plane has various uses, including onboarding new customers, billing and invoicing, updating the catalog database, storing initial information in a user's database, provisioning application instances, and monitoring and observability. Automating tasks like onboarding or schema migrations can make them faster and safer as an organization scales. Key takeaways for designing an effective control plane include starting simple and scaling thoughtfully, treating the control plane like an internal product, centralizing metadata, picking battles wisely, and using the catalog database for insights. The control plane integrates and standardizes operations on the data plane, making it legible and comprehensive, thus minimizing risks of technical operations.

Neon, a serverless Postgres service, offers an innovative approach to multi-tenant applications through a database-per-user architecture, facilitating customer data isolation and operational scalability. Central to managing these systems is the control plane, which integrates with tools like the Neon console and neonctl to manage and automate tasks across various projects. The control plane concept extends beyond Neon’s built-in tools, encompassing systems for CI/CD, observability, and schema migration. To efficiently manage multiple Neon projects, the importance of a catalog database is emphasized, serving as a centralized repository for metadata, user information, and operational data, thereby streamlining operations and enabling effective scaling. The control plane's pivotal role involves onboarding new customers, managing schema migrations, and ensuring consistent updates across databases, with a focus on automation and standardization to enhance operational efficiency. As the control plane evolves, it aims to centralize governance over data resources, minimizing risks and facilitating a synoptic view of operations, crucial for scaling and maintaining a robust database-per-user architecture.

BaseHub is a new headless CMS designed to streamline content management for developers and editors. It offers features like versioning, AI-driven content modeling, and branching (coming soon). The platform is currently in Public Beta with a free tier available for signup. BaseHub's team has experience building content-heavy websites and prioritizes collaboration and developer-friendly APIs. They have also launched a collection of customizable templates built with Next.js to help developers kickstart their web projects. The company initially started building on Supabase but switched to Neon for its production database due to cost inefficiencies and lack of compute autoscaling. Neon is a special kind of Postgres service that adds an autoscaling experience, dynamically adjusting resources based on actual demand. This feature helps BaseHub reduce unnecessary overhead during quieter times and automatically scales up during high-traffic moments. Another key feature of Neon is database branching, which enables developers to create isolated database copies for testing without relying on traditional backups. This not only makes migrations smoother but also speeds up debugging while reducing operational costs. BaseHub uses the Neon serverless driver to connect Cloudflare Workers directly to Neon, improving query speed and performance across regions. In summary, BaseHub is a modern headless CMS that aims to make content management fast, simple, and collaborative for developers and editors. It aligns with Neon's priorities of providing an efficient developer experience, flexibility, and a free tier.

BaseHub, a modern headless CMS aimed at enhancing developer velocity and collaboration, leverages Neon's serverless architecture to efficiently manage database operations. Initially built on Supabase for its convenience, BaseHub transitioned to Neon as its user demand and traffic variability increased, necessitating autoscaling capabilities to manage costs effectively. Neon provides a dynamic scaling solution that adjusts resources based on demand, thus reducing overhead during low-traffic periods and enabling cost-efficient management of non-production environments. Furthermore, Neon's branching feature, utilizing a copy-on-write approach, allows for instant database branching, facilitating safer testing and debugging without affecting live databases. This, combined with the Neon serverless driver, enhances query speed and performance across regions, aligning with BaseHub’s priorities of providing a smooth developer experience and operational flexibility.

This blog post discusses how to set up an embeddings indexing pipeline using Redpanda and Neon without writing any code. The process involves reading data from Redpanda, computing embeddings using Ollama, and writing output into Neon for efficient storage and querying of embeddings. Redpanda's compatibility with the Apache Kafka® protocol ensures smooth data ingestion and handling, while Neon's serverless Postgres architecture and pg_vector extension provide efficient storage and querying of embeddings. This setup simplifies the process of building indexing pipelines, making them scalable and high-performing for various applications such as e-commerce transactions or customer reviews.

Building high-throughput, scalable embeddings indexing pipelines can be simplified using Redpanda and Neon, as demonstrated in a blog post that details a no-code setup for this process. By leveraging Redpanda for data ingestion and Neon for efficient indexing within a managed environment, users can create robust pipelines suitable for tasks such as indexing e-commerce transactions. Redpanda's compatibility with the Apache Kafka protocol facilitates smooth data handling, while Neon's serverless Postgres capabilities with pgvector extension ensure efficient storage and querying of data embeddings. The blog outlines a practical example where invoice data from an e-commerce application is processed, with Redpanda acting as an intermediate buffer and Ollama used for computing embeddings, before the data is stored in Neon for querying. This approach offers a streamlined solution for building scalable and high-performing indexing pipelines without the need for extensive coding, making it accessible for various data processing projects.

Neon has introduced an automatic scaling feature for its Postgres instances to keep the working set in memory. The working set size is estimated using HyperLogLog (HLL), a probabilistic algorithm that estimates the cardinality of a set with high accuracy and minimal memory usage. By dynamically estimating and adjusting the working set size, Neon can provide significant speed-ups for real-world workloads while ensuring predictable performance. The new feature is expected to be more cost-efficient than fixed-size nodes with the same performance.

Neon has introduced an autoscaling feature that dynamically adjusts Postgres instances to match the workload's working set size, optimizing performance and cost-efficiency. This innovation leverages techniques like HyperLogLog for estimating the working set size and introduces a time-bounded variant to better handle varying workloads by using sliding windows with timestamps. The approach aims to maintain the working set in memory, significantly boosting throughput and ensuring predictable performance, especially in read-heavy workloads where cache misses can incur latency due to network-based storage. The method seeks to strike a balance between responsiveness and resource efficiency, particularly for workloads that fluctuate over time. Initial results show that this strategy improves performance while being more cost-effective than fixed-size nodes, although it does present some edge cases and potential areas for future refinement. Neon draws inspiration from similar efforts by AWS Aurora, suggesting a potential for standardization in working set estimation techniques across platforms.

Neon, a serverless Postgres database, offers migration guides for teams looking to switch from AWS RDS/Aurora with minimal downtime. Migration strategies depend on the size of the database and tolerance for downtime. For smaller databases or tolerable downtime, dumping and restoring is recommended. Larger databases or those requiring minimal downtime can use logical replication to maintain operational continuity during migration. Neon's documentation provides detailed guides for both strategies.