Postgres 19 is stable on Layerbase
Start a new database on PostgreSQL 19.0 or upgrade your existing 19 beta database, including on the Free plan.
Engineering deep dives, migration guides, and tutorials for every database engine Layerbase supports.
256 posts across the blog · Featured first, then most viewed in the last 30 days
Start a new database on PostgreSQL 19.0 or upgrade your existing 19 beta database, including on the Free plan.
Moving off Gadget means replacing more than a database. Map your Shopify app to Postgres, application hosting, auth, scheduled jobs, and queues before the March 2027 shutdown.
Layerbase can now turn a MongoDB or DocumentDB database into PostgreSQL tables, with a mapping you review first and checks before you switch.
An AI agent can now register its own Layerbase account, pay for a plan, and create databases over MCP without a person signing in first. Later, you claim the account with Google or GitHub. Free accounts can also connect agents over OAuth.
Oracle stopped patching MySQL 8.0 on April 30, 2026. Here is what actually breaks on the way to 8.4 LTS, 9.7 LTS or MariaDB, how long each one is supported, and which move fits which app.
On October 30, 2026, new tables in a Supabase public schema stopped showing up on the Data API until you GRANT them. The error is 42501. A direct connection as the table owner is unaffected. That split is the decision.
Neon branches Postgres. PlanetScale branches MySQL. Layerbase branches all of them, because branching happens at the filesystem, not inside the engine. Here is how it works.
Northflank gives every pull request its own stack, and the database in that stack starts empty unless you seed it or restore it from a backup you already had. Here is exactly how their forks work, what a copy-on-write branch does differently, what each one costs while a PR sits open, and the cases where Northflank is the right answer.
Run the Codex CLI on a Linux server with your ChatGPT account. Sign in with a device code, clone your repo into a worktree, and come back to the same session later.
Comparing pgEdge Starfleet with Layerbase for startups and small businesses: entry prices, database branching, Postgres plus a cache, and when enterprise deployment options matter.
Every platform on this list will give a pull request its own URL. The question that sorts them is what is in the database behind that URL: nothing, a restore of last night's backup, or the live data as of right now. Here is where each of eleven platforms lands, quoted from their own docs, and what a preview costs while the PR sits open.
D1 charges 1,000 times more per row written than per row read, counts index entries as writes, and has no spending cap on the paid plan. How the bill adds up, what usually causes it, and how to audit your own usage.
If your Node app just started printing a SECURITY WARNING about SSL modes being treated as aliases for verify-full, nothing is broken and nothing has changed yet. Here is what the warning actually means, why it appeared out of nowhere, and the one-line connection string fix.
libSQL is the open source SQLite fork. Turso is the company behind it, its managed platform, and now a separate Rust rewrite with the same name. Here is how the three fit together in September 2026.
MongoDB, FerretDB, and standalone DocumentDB side by side, with August and October results clearly separated. Throughput, update p99 latency, and what the two runs can tell us.
Run a Cloudflare Worker against Postgres with Hyperdrive. A practical setup, the separate hosting and database costs, and what changes when you leave Supabase.
Neon is excellent serverless Postgres with a bill shaped like compute-hours and branch-months. That shape fits a bursty production app and fights a stack of small, mostly idle databases. Here is what Neon actually is, where the meter bites, the current plan numbers, and an honest list of reasons to stay.
DuckDB 2.0 is live on Layerbase Cloud. Run analytical SQL through a hosted connection, explore your data, and build reports. Query account PostgreSQL and MariaDB sources and save snapshots in managed DuckLake.
Upstash prices Redis per command and reaches it over HTTP. Redis Cloud prices it by memory and sells the query engine, JSON, and Active-Active on top. A 2026 comparison of the billing models, the free tiers, the connection limits, and what a small always-on app and a bursty serverless app actually cost on each.
What Railway reported on October 20 and 21, what a separate database does and does not protect, and a practical recovery checklist with a manual Postgres migration.
Redis Cloud prices itself around the module story: search, JSON, time series, vector sets, Active-Active. If you use those, the bill is buying something real. If you use Redis as a cache, a session store, or a queue, you are paying the module premium for a key-value store. Here is what each tier buys, where a flat plan fits, and when to stay.
InfluxDB 3 Core refuses queries that touch more than 432 Parquet files, which at the default 10-minute file duration works out to about 72 hours of data per query. The data is still there. Here is the mechanism, the knob, what Layerbase actually runs, and the two honest exits.
Store points, lines and polygons in Postgres and query them by distance, area and containment. Turn on PostGIS per database from the Extensions tab or with one CREATE EXTENSION, on every plan, with no restart.
Upstash bills Redis per command, which is brilliant for a tiny app and a meter for everything else. Every Redis and Valkey on Layerbase exposes the same REST API the @upstash/redis client speaks, and every Valkey carries an HTTP queue supporting documented QStash client operations. Here is the arithmetic, the code that does not change, and when Upstash is still the right call.
Bring your agents out with you. Set up a Linux VM at your desk, then return to Claude Code or Codex from your phone with your repositories and tools already there.
PostgreSQL 19.0 is now available on Layerbase. This article tracks the beta and release candidates that preceded the stable release.
Run SQL on a schedule inside your Postgres database. Turn on pg_cron from the Extensions tab, create jobs from templates, read their run history, and know exactly how jobs behave when a database sleeps.
Neon counts compute units. Aurora counts ACU-hours. Cloudflare D1 counts rows scanned. Upstash counts commands. Turso counts rows read. Every serverless database bill is a formula, and the variable is always something your code controls without telling you. Here is each meter, and what a flat price costs instead.
There are too many vector databases and most teams need one or two of them. Here is the honest shortlist for 2026, when to pick each, and why pgvector is the default until it isn't.
MotherDuck quietly retired the $25 Lite plan and raised the Business plan from $100 to $250 per month. There was no announcement. Here is what changed, who it affects, and where to host DuckDB if the new pricing does not fit.
Compare CouchDB alternatives for offline-first sync, document storage, managed hosting, and relational data. The right replacement depends on which part of CouchDB you actually use.
PGlite is a real Postgres compiled to WASM, so graduating a prototype to a hosted database is a dump and a restore, not a rewrite. Here is the whole path, start to finish.
MariaDB 13.0 and 12.3 are now offered on Layerbase alongside 10.11, 11.4 and 11.8, and the older lines have been refreshed to their current patches. Here is what actually shipped in 13.0, what 12.3 changed, why one of them is the LTS and the other is not, and what happens to databases already on 11.8 (nothing).
A binary that runs fine on your machine can be structurally incapable of starting on Ubuntu 22.04. It happened to us three times in one month, from three different directions, and nothing in the release pipeline was looking.
YCSB against MongoDB 8.0 and FerretDB 2.7 on the exact hardware behind our $65/mo dedicated preset. Once our own tuning was right, FerretDB held 3-4x MongoDB throughput on the mixed workload and about 5x on reads. The corrected numbers, what had to be fixed first, and what we are not claiming.
What you actually get when you leave MongoDB Atlas for DocumentDB or FerretDB on Layerbase: the same wire protocol and driver, a free plan or a flat monthly price instead of a per-tier meter, branching Atlas does not offer, and the cases where you should stay put.
The MongoDB alternatives people actually compare, starting with open-source DocumentDB and FerretDB, then Atlas itself, Azure, Amazon DocumentDB, Firestore, Couchbase and plain PostgreSQL JSONB. What each one is, what it costs to start, and what it asks you to change.
Postgres is my default for a Next.js app on Vercel. Here is how Layerbase, Neon, Supabase, PlanetScale, Turso, and Convex compare on pricing, connections, and preview database branches.
A three-way comparison of the vector databases that keep showing up in RAG stacks: architecture, hosting model, current pricing, hybrid search, and multi-tenancy. Verified prices, no borrowed benchmark charts.
D1 is SQLite, so your SQL is portable. The coupling is somewhere else: there is no wire protocol, the SQL export rounds any integer past 2^53, and you cannot get the file underneath. Here is an honest inventory, the alternatives, and when staying on D1 is the right call.
AWS is acquiring the company behind DuckDB and says the project stays free and open source. The articles of association the DuckDB Foundation publishes never mention MIT, and two of its three board seats belong to people who become AWS employees at close.
Both are Postgres companies and they are not competing for the same job. A row-by-row comparison from their own docs: branching, free tiers, pricing shape, the security rows nobody reads until procurement asks.
Neon, Aurora Serverless v2, Supabase, PlanetScale Postgres, and Layerbase all answer to "serverless Postgres" and mean different things by it. What each one actually does at idle, how you connect from a serverless runtime, and where each one is the right pick.
A SQLite file stops working the moment something other than one process needs it. Here is how to put the same file behind an address, with a Postgres driver or the libSQL client, without rewriting a schema.
Turso Cloud added Frankfurt and Singapore after the acquisition announcement. Here’s what changed for hosted databases and what it means if you run libSQL yourself.
MySQL is not on the Layerbase free tier and MariaDB is, and they speak the same wire protocol. Here is the dump command that survives a restricted source account, every error the restore actually throws, what MySQL keeps that MariaDB does not, and the route back to real MySQL later.
Aiven prices every service on its own hourly meter, so a Postgres plus a MySQL plus a Valkey is three plans and three line items, at three different prices. Here is the arithmetic against a flat Layerbase plan, the real shape of both free tiers, and the four things Aiven does that we do not do at all.
Every free Redis tier is generous until it hits its one real ceiling. Upstash counts commands, Redis Cloud caps you at 30 MB and 30 connections, Render throws your data away on restart, and Layerbase puts idle databases to sleep. Here is what each one runs out of first.
The Layerbase CLI is usually introduced as a way to run databases without Docker. This is about the other half of the surface: every command speaks --json, every failure sets an exit code, and nothing hangs waiting for a keyboard. Test runners, CI jobs, and plain shell scripts can drive it like an API.
OrioleDB is an open-source storage engine for Postgres. It replaces heap tables with an undo log so update-heavy tables stop leaving dead rows behind. It is a Supabase public beta, not a new database, and you cannot turn it on later.
DocumentDB 1.0 joins Layerbase Cloud alongside FerretDB. Run MongoDB-compatible workloads on Free, Solo or Pro, or try it locally on Linux without Docker.
Redis OSS ships no native Windows binaries. Run Redis natively on Windows without Docker or WSL using custom binaries from Layerbase Desktop or SpinDB.
Aiven, PlanetScale, Render, Neon, Supabase and more compared by the paid tier that keeps one small Postgres awake. RAM, backups, connections, regions, HA, and a short MySQL guide.
Conversation state with TTLs, BullMQ queues for scheduled reminders, idempotency keys for retried webhooks, and per-recipient rate limits, all on one Redis-compatible Valkey.
Commands, RESP and client libraries are still interchangeable. The data format is not: Redis 7.4 and later write an RDB that Valkey refuses, and Valkey 9 writes one that Redis refuses. Verified against both source trees in September 2026.
Starting November 4, 2026, any D1 query that returns more than 50 MB fails. What changes, which queries hit it, how to fix them without paying more in rows read, and when it makes more sense to move the database to libSQL.
Nobody branches a time-series database. Neon branches Postgres, PlanetScale branches MySQL, and telemetry data gets a stale CSV sample. QuestDB and InfluxDB branch on Layerbase now, and it changes how you test against real metrics.
Graduating a local database used to be five steps and a copy-pasted connection string. The promote command in the Layerbase CLI does the whole thing: create, import, connection string, and an optional .env rewrite.
Qdrant 1.19 and Weaviate 1.39 compared on hybrid search, quantization, multi-tenancy, filtering, licensing and verified September 2026 cloud pricing, with side-by-side TypeScript and a straight verdict.
The Lovable plus Supabase combination is great for the first 100 users. Here is what actually breaks at scale, and the path off without rewriting your app.
Start with DuckDB 2, query PostgreSQL and MariaDB together, and save analytical snapshots to DuckLake with managed R2 storage.
Vercel Postgres was white-labelled Neon, and it was wound down into a Neon Marketplace integration between Q4 2024 and Q1 2025. If you still import @vercel/postgres, here is what you are actually running, what has to change in the code, and how to land on flat-priced managed Postgres with the connection string you already have.
pgrun gives every agent, CI run, or pull request a disposable branch of your production Postgres. Here is what it actually does and where its limits are, how to get the same workflow locally for free with the Layerbase CLI, and the hosted alternatives worth comparing: Neon, Xata, and DBLab Engine.
Embeddings are expensive to compute and easy to ruin. Qdrant, Weaviate, and Meilisearch all branch on Layerbase now: fork the store per eval run, per agent, or per risky reindex, and throw the fork away.
Leave the laptop shut. A Layerbase Agent Server is a small Linux computer that stays on, with your GitHub repos and your coding agent already signed in. The phone is the screen, and with Codex it can be the microphone.
An analytics project is three things: sources, a pipeline, and a result. Only the result needs an address. Here is what moves, what stays on your laptop, and what changes the moment a .duckdb file goes over a wire.
QuestDB 9.4 lets a table declare Parquet as its partition format at CREATE TABLE time. Here is what Parquet actually is, why a time-partitioned table is the ideal shape for it, and how the feature behaves on a real database.
Algolia is excellent and expensive. Meilisearch gives you 90 percent of the developer experience at a fraction of the price, with a managed option that does not charge per search. Here is the honest comparison.
An app builder, personal agents, and a VM for your coding tools solve different problems. Compare the workflow before choosing where your agents should run.
Turso is the dominant libSQL host, but its per-row-read pricing surprises many users on real workloads. Here are alternatives, including self-hosted libSQL.
Vercel Postgres is not a product anymore, so this is really Aiven versus a Neon project bought through the Vercel Marketplace. Which one fits, what each costs as of September 2026, and the questions to put in front of a proof of concept before anyone signs.
Every vendor just launched an agent-native database and each one wants to be the whole answer. But an agent's state is not one thing. Here is how it actually decomposes, and what to run for each part.
Compare Layerbase Agent Servers, Coder, Ona, and a DIY VPS by what persists, who operates the environment, and how you pay. Codespaces may still be the right choice.
No official Valkey Windows binary exists anywhere. We manually compiled one so you can run Valkey natively on Windows without Docker or WSL.
Connect Obsidian Self-hosted LiveSync to managed CouchDB, configure a private sync database, add another device, and verify offline recovery.
A practical comparison of SQLite and LibSQL covering server mode, replication, vector search, and when to pick each one.
What Railway’s October disclosure means for credential rotation, how Vercel’s earlier incident compares, and a practical Layerbase database workflow with GitHub and Vercel.
A database that scale-to-zeros after five minutes, a project that pauses after a week and needs a human to click Resume, and a database that gets deleted 44 days after you created it are three different products. Here is which vendor does which, and what the cheapest always-on version costs.
A complete, dated rundown of what IBM Cloudant has changed, deprecated, or removed in the last 18 months, including the new 20-database Lite-plan cap, the SpiderMonkey to QuickJS cutover on October 6, 2026, and the removed CouchApp design-doc handlers. With migration paths if any of these break your app.
IBM Cloudant has been the default managed CouchDB for over a decade, and the Lite free tier has quietly gotten less generous. Here are the modern managed CouchDB hosting options, including a flat-rate managed CouchDB, serverless scale-to-zero, and one-step migration off Cloudant.
Lovable runs on Supabase by design, and you cannot swap in your own Postgres from inside a Lovable-hosted app. Here are the two paths that actually work, and where your own database fits.
Vercel KV was sunset and its stores moved to Upstash Redis, so the move is a data copy and a one-line client swap. Paste the rediss:// string behind your project Storage tab and copy every key, type, and TTL into flat-priced managed Redis or Valkey.
Kuzu (KuzuDB) is a fast embedded graph database, but with no server and no managed hosting. When to move to a managed graph database, and how TypeDB fits.
Connect a repository, give your coding agent a task, and come back to the same development environment from another computer. A practical guide to building in Layerbase Agent Servers.
ClickHouse Cloud Basic starts at $66.52 a month and meters compute by the minute in 8 GiB steps. That is a fair price for a real analytics platform and a strange price for a staging database or a side project event pipeline. Here is what the tiers actually buy, where a flat $15 plan fits, and when you should keep paying ClickHouse.
Turso meters reads and writes per row, which gets unpredictable on real workloads. Here is how to move your libSQL database to flat-priced managed hosting on Layerbase: dump it, load it, and point the same libSQL client at a new URL.
Crunchy Bridge is Postgres specialists selling instance-hours across AWS, Azure and GCP. Layerbase is a flat monthly price, 19 engines and branching. A head-to-head on pricing, versions, extensions, HA, backups and placement, with worked examples.
Do you need a dedicated vector database, or is Postgres enough? A specific comparison of pgvector 0.8.6 and Qdrant 1.19: filtered search, quantization, index memory, and the code for each.
Continuous WAL archiving and restore-to-any-timestamp are now switchable from the Backups tab of any always-on PostgreSQL or FerretDB database on the Pro plan. A restore builds a new database and never touches the source. FerretDB gets it because its documents live in Postgres, and we proved that over the MongoDB wire before writing this.
A practical guide to choosing between SQLite, LibSQL, and DuckDB when your project does not need a standalone database server.
Discover customer trends, understand product usage, and find opportunities for growth using familiar SQL. Follow along for free on Layerbase.
pgx through a transaction-mode pooler fails with prepared statement "stmtcache_1" already exists. Not on the first connection, which is what makes it dangerous. Here is the measurement, the wrong diagnosis we published first, and the server-side fix.
Set up PayloadCMS with managed PostgreSQL or MongoDB-compatible FerretDB on Layerbase Cloud, and why FerretDB beats MongoDB for most Payload projects.
Install Claude Code on a Layerbase Agent Server, sign in with your own account, and run it in a persistent browser terminal. Keep machine costs and model billing separate.
Testcontainers is excellent, and its one hard requirement is a Docker-API compatible runtime. If the only thing your tests need is a real database, you can get the same throwaway instance without a container runtime at all.
Your agents get their own computer. You get a way to reach it from your phone, for an urgent fix, a quick feature, or a check on the work you started at your desk.
A 2026 comparison of Algolia and Meilisearch: ranking models, typo tolerance, faceting, hybrid search, analytics, merchandising, limits, licensing, and what each one costs at 10K, 100K and 1M records.
Create a DuckDB database on Layerbase today and you get 1.5.5, the release the DuckDB team shipped two days earlier. Here is what the 1.5 line adds and what managed DuckDB on Layerbase actually gets you.
Lovable defaults to Supabase. Here is the honest shortlist of what else to use for the database layer, and when each one is the right pick.
AI-powered Lovable apps eventually need vector storage for RAG, semantic search, or recommendations. Here is the working version with Qdrant on Layerbase Cloud.
Move MongoDB or DocumentDB into PostgreSQL, edit the table mapping, approve relationships, and inspect verification before switching your application.
Your database is on a shared host that binds MySQL to localhost, runs a version you did not pick, and keeps the only backup. Here is the whole move: getting a dump that is actually complete, landing it on managed MariaDB, repointing the app, and the parts of shared hosting you will genuinely miss.
Our nightly restore drill caught a restore that reported success and handed back an empty database. Here is the race that caused it, how we found it, and why we drill restores instead of trusting green backup jobs.
QuestDB Cloud is discontinued and the official path is a sales-gated Enterprise/BYOC product. If you want managed QuestDB with a signup form instead of a sales call, here is the 2026 state of play.
Xata rebuilt itself as a copy-on-write Postgres branching platform and retired the 15 GB free tier along the way. Cloud now starts at $0.012 an hour plus storage with a 14-day trial. Here is what that costs a side project, what the new Xata is genuinely good at, and where to land if the free tier was the reason you were there.
The reason people pick Neon is branching. The reason they leave is the bill that arrives once branching becomes a habit: a compute meter per branch, a branch-month past the included ten, and the arithmetic before every pull request. Here is what a branch-per-PR workflow costs on a meter, what the same workflow looks like inside a flat plan, and the honest list of what Neon still does better.
MotherDuck is the dominant managed DuckDB, but its pricing and proprietary layer are not for everyone. Here are the alternatives, including plain hosted DuckDB.
FerretDB v2 needs a PostgreSQL extension that is not on Windows yet. We built custom binaries to run FerretDB v1 natively on Windows, no Docker or WSL.
A step-by-step guide to migrating from Redis to Valkey, covering data transfer, application changes, and the one gotcha worth knowing about.
PostgreSQL for persistent data plus Redis for real-time features is the proven stack for building chat applications at any scale.
Timescale rebranded to TigerData, the cloud is Tiger Cloud, and the extension is still called TimescaleDB. If you use hypertables we are not your migration path, and this post explains exactly why. If you are on Tiger Cloud running ordinary Postgres, or you want managed time-series without an extension license in the middle, read on.
PlanetScale retired its free Hobby tier, and the smallest Vitess MySQL cluster is now a 3-node HA SKU at $39 a month. Here is how to move to plain managed MySQL on Layerbase: what changes, how to copy your data with one service token, and the driver swap.
QuestDB retired its self-serve cloud for Enterprise BYOC. If you want a managed QuestDB instance without a sales call, here are the options that still exist.
Build a multi-party payment system with TigerBeetle and TypeScript using double-entry bookkeeping, two-phase transfers, and balance limits on a pre-1.0 ledger.
Build a knowledge graph with TypeDB 3.x and TypeQL 3, covering type-safe schemas, pattern matching, multi-hop traversals, and functions that derive facts you never inserted.
The Hobby plan closed in March 2024 and PlanetScale docs now say plainly that there is no free plan. Here is what replaced it, what $5 a month actually buys in 2026, and when paying PlanetScale is still the right call.
Choose a Deno KV replacement by workload, map atomic operations to Valkey or Postgres, and rehearse a small export and import before moving your application.
Build a TypeScript browser scratchpad that saves locally, replicates to CouchDB, reconnects after going offline, and exposes conflicting revisions.
TypeDB is not a property graph with extra syntax. Entities, relations with named roles, and attributes are three independent kinds of type, and TypeDB 3 replaced inference rules with typed functions. Here is what that changes about how you model.
What "serverless CouchDB" actually means in 2026, why the category is small (one long-running hosted option, IBM Cloudant, plus flat-rate managed CouchDB on Layerbase Cloud), and how to ship an offline-first or document-store app without managing the database yourself.
Lovable runs in the cloud, but you still want a local copy of the app pointing at a local database for testing. Here is how to do that without Docker, in under a minute.
A practical ClickHouse vs DuckDB comparison with side-by-side code, covering when to pick a production analytics server versus an embedded engine.
A side-by-side comparison of QuestDB and InfluxDB for time-series workloads, with identical sensor pipelines in TypeScript to show how different they are.
Skip the containers and docker-compose files by running PostgreSQL, Redis, and other databases as native binaries with a single CLI command.
New Valkey databases on Layerbase run 9.0, and since the August security wave the build is 9.0.5. Here is what actually shipped in Valkey 9, which of it a single managed instance benefits from, what 9.1 added, and what happens to databases already on 8.0 (nothing).
We built importers from Cloudflare D1 and Turso into libSQL and found seven data-fidelity bugs. They turned out to be the same two bugs, and neither one is really about SQLite.
VQueue adds safer publish retries and verified payload archiving. Where its included HTTP queue fits alongside QStash, Cloud Tasks, and Trigger.dev.
Move your Postgres and your Supabase Auth users to Layerbase in one pass. The password hashes come across untouched, so you skip the forced reset, then you wire login against your own database.
Vercel KV was first-party Redis built on Upstash, and it was sunset into Upstash Redis on the Vercel Marketplace. If you want a Redis you own at flat pricing, here is how to move to managed Valkey with the rediss:// string you already have.
Fly emailed customers that Fly Machines memory prices rise 20% on October 1, 2026. CPU stays the same, and Sprites get cheaper. Here is what that does to a Postgres cluster, and how to move the database without moving the app.
A free database is a starting point. Before you commit, understand what production, branches, backups, and a quiet month will actually cost your SaaS.
Build a bookmarks and knowledge base app with LibSQL and TypeScript, covering SQL fundamentals, JSON queries, native vector search, and batch transactions.
ClickHouse Managed Postgres has left beta and Xata is joining the company. Compare the current billing model with Layerbase, including the integration and capacity differences.
TypeDB 3.12 landed this week with a given stage for injection-safe batch queries, @doc and @meta schema annotations, a new bulk loader, and an admin service that is off by default. You can spin one up free on Layerbase in seconds.
If you build software for clients, you do not have a stack. You have everyone else's. Here is how to run all of those databases, local and hosted, from one place.
A practical guide to picking the right database for IoT sensor data, covering QuestDB, InfluxDB, and PostgreSQL with SpinDB examples you can run locally.
Algolia bills every keystroke. Meilisearch does the same instant, typo-tolerant, faceted search on a flat plan. What the meter really costs, and a step-by-step guide to rebuilding your Algolia setup (keys, ranking, facets, replicas, geo, InstantSearch) on Meilisearch.
Snowflake bought Crunchy Data in June 2025. Bridge is still sold, still documented, and nothing has been announced about sunsetting it. Here is the dated record, what it actually implies, and the reasons to move that have nothing to do with the acquisition.
Every Layerbase Postgres now speaks the HTTP protocol used by @neondatabase/serverless. Pass your normal connection string to neon() and query from Vercel Functions, Cloudflare Workers, or AWS Lambda with no TCP socket, no VPC, and no RDS Proxy. Here is what works, what does not, and how it is built.
A practical comparison of PostgreSQL, MySQL, MariaDB, and CockroachDB to help you pick the right relational database for your project.
Lakebase is Databricks' managed Postgres, built on the Neon platform they bought for $1 billion. It is a good database. It is also one more Postgres provider now owned by a $60B enterprise company, with metered billing and a roadmap that answers to enterprise data teams. Here is the honest comparison, and where Layerbase fits.
MongoDB never got Neon-style branching. Layerbase Cloud gives it to you: a serverless, Mongo-compatible database you branch from the dashboard in seconds, plus the same workflow locally with SpinDB or Layerbase Desktop.
A practical guide to moving search from Algolia to Meilisearch: what maps cleanly, what does not, how to copy records and settings, and the frontend swap.
Build a time-series sensor pipeline with QuestDB and TypeScript, learn why SAMPLE BY beats verbose GROUP BY queries, and run it all in one script.
Nebius is an AI cloud: GPUs, inference, training infrastructure. It ships a Managed PostgreSQL too, but the database catalog is thin. Here is what to actually run for the data layer behind your Nebius workloads.
Move your Neon Postgres to flat-priced managed Postgres in one pass. The database is the easy part. This is the honest version, including what happens to Neon Auth and how the pooled connection string trips people up.
Tinybird turns ClickHouse into a managed real-time analytics API with usage-based billing. Layerbase gives you the same ClickHouse engine on a flat monthly price and leaves the API layer to you. Here is the tradeoff, and when each one wins.
A practical guide to migrating from MongoDB to FerretDB, covering what works out of the box, what breaks, and how to check your codebase before switching.
We measured every database engine we run to find out whether dumping an unchanged database twice produces the same bytes. Most do not, for a different reason each time, and three cannot be fixed at all.
sslmode=require is the only value that connects on every client we tested. verify-full fails on all stock libpq. sslrootcert=system crashes node-postgres before it opens a socket. Here is the measured matrix, with exact versions and the real error strings.
A direct head-to-head between IBM Cloudant and Layerbase Cloud for managed Apache CouchDB hosting. Compares entry pricing, database-count caps, the billing model, JavaScript engine, migration path, region coverage, and operational ergonomics, with a recommendation for each common workload.
Netlify DB is Neon Postgres that Netlify operates and resells, billed out of the same credit balance as your builds. Here is what that coupling costs you, what Netlify genuinely got right, and how to move the data without moving the site.
Fly Managed Postgres starts at $38/month per cluster, adds $0.28 per provisioned GB, and is deliberately unreachable from the public internet. Here is what that costs a side project, why the private networking is defensible, and when to run the database somewhere else.
Railway ships databases as deploy-a-container templates, and its own docs hand you backups, tuning, security, and monitoring. That is a defensible design. It is also not what most people think they are buying.
Supabase Edge Functions connect from rotating, shared egress IPs, so IP allowlisting cannot pin them. Here is how to lock down a Postgres database with client-certificate (mTLS) auth and connect to it from a Deno edge function, step by step.
Meilisearch Cloud starts at $20 a month, has no free plan, and bills per instance or per usage, for a search engine that is open source and runs anywhere. Here is what the Cloud tiers actually buy, where a flat $15 plan with Meilisearch 1.52 fits, how to move an index, and when the Cloud is still the right call.
Serverless does not mean there is no server, and it does not mean cheap. It means nobody hands you a capacity slider, and an idle database should not cost what a busy one costs. Here is what the term actually promises, and the two very different ways vendors deliver it.
Vercel KV was sunset and every existing store was moved into Upstash Redis in December 2024. The @vercel/kv client on npm is formally deprecated and has not shipped a release since 2024. Here is how to find out what you are actually running, and how to move it onto managed Valkey.
Qdrant 1.18 is the new default line on Layerbase. Here is what a vector database is actually doing, why quantization decides what your index costs to run, and what landed between 1.16 and 1.18.
FerretDB gives you the MongoDB API on top of PostgreSQL, under an Apache 2.0 license. Here are seven concrete reasons teams pick it over MongoDB, and an honest list of when you should not.
What leaving Lovable actually costs depends on what your app uses. The export limits, hosting prices, work you still have to do, and the math to decide whether moving pays for itself.
The July beta introduced Postgres 19 on Layerbase. PostgreSQL 19.0 is now stable, and existing beta databases can upgrade on Free.
We measured what a D1 SQL export does to a 64-bit id: 9223372036854775807 comes back as 9223372036854776000, and the storage class flips from integer to real. Cloudflare documents the cause in one sentence. Here is the measurement, and the encoding that round-trips instead.
D1 is great if your app is a Worker. If it is not, you are reaching your database through a function you did not want to write. Here is how to move a D1 database to managed libSQL, and why we do not use D1's own export to do it: the SQL dump rounds any integer past 2^53.
Upstash bills per request, which is great at zero traffic and surprising at scale. Here is how to move to flat-priced managed Valkey on Layerbase: copy every key with one API key, and swap the REST client for a standard Redis driver.
Build and test an offline survey sync workflow with CouchDB, including replication, concurrent edits, conflict detection, and production backup guidance.
Hourly dumps mean a bad DELETE at :59 costs you most of an hour, unrecoverably. We built continuous WAL archiving and restore-to-any-timestamp for always-on Postgres on Layerbase, then proved it with an executed drill: the row written two seconds before the target came back, the row written four seconds after it did not.
Render's free Postgres expires after 30 days and the paid tiers climb fast. Here is how to move to managed Postgres on Layerbase with one API key, with no expiry clock and flat pricing.
Give your agents their own computer. Connect your GitHub repos and use Claude Code, Codex, and other CLI tools from your desktop or phone.
A Windows executable that exits instantly with 0xC0000135 and no message, while the DLL it needs sits in a subdirectory next to it. Windows does not look there, and the equivalent trap exists on macOS and Linux too.
You can now create a Layerbase database in EU West, in France, on every plan including Free, at no extra cost. What moves to the EU, what stays in the US, and how to pick the region from the dashboard, CLI, Desktop or MCP.
An honest look at Cloud Clusters PostgreSQL hosting (pgsclusters.com): what it does well, where it falls short, and why we think Layerbase is the better home for a managed Postgres in almost every case.
Xata is not shutting down, and there is no announced migration deadline. What the ClickHouse acquisition means for your Postgres branches, pricing, and options.
Before you self-host your SaaS database in 2026, budget for backups, recovery, security, upgrades, and your own time. The server rental is only the beginning.
Xata is unmodified Postgres now, so leaving it is a dump and a restore. Here is what copies across, what stays behind (branches, pgroll history, anonymization rules), the connection-string detail that makes or breaks the copy, and how to rebuild your preview branches on the other side.
Move your Replit Postgres to Layerbase without moving your app. Production databases are a connection-string paste; development (Helium) databases need one command from the Repl shell. Includes the driver question and how to verify the copy landed.
An honest review of Cloud Clusters Oracle hosting (oclusters.com). It runs real Oracle, but only the 11g Express edition. Here is when that is fine, and why Postgres on Layerbase is the better fresh-start choice.
Publish, schedule, inspect, and replay HTTP jobs with VQueue. Included with Layerbase Valkey under documented limits.
A practical guide to running PostgreSQL, Redis, Qdrant, ClickHouse, and other databases side by side on your local machine without the configuration headaches.
A serious Lovable app usually needs more than one database: durable state, a cache, and vector search. Here is how to wire all three in, the correct way, from a browser SPA that has no server of its own.
Build a distributed orders system with CockroachDB and TypeScript, using standard SQL over the PostgreSQL wire protocol with sharding and automatic replication.
Databricks rebuilt Postgres so that object storage is the database. We shipped a much smaller thing: the write-ahead log leaves the box continuously, the live database stays on local disk. Here is the whole design, the two bugs that taught us the most, and an honest account of what this architecture does not buy.
DigitalOcean's October 2026 changes move larger new Postgres and MySQL clusters to Advanced Edition. Compare the current cluster prices, the new limits, and Layerbase's shared flat-price plans.
A practical comparison of MongoDB and FerretDB covering wire protocol compatibility, storage engines, licensing, and where each one makes the most sense.
A practical comparison of Docker Compose and SpinDB for running local development databases, covering setup, resource usage, and when each approach makes sense.
DBngin starts a local Postgres in one click and asks nothing of you, which is why it keeps showing up as the answer to running databases without Docker. The ceiling is the shape of the app: no command line, so nothing it does can be scripted, checked into a repo, or run on a CI machine.
Lovable ships a browser SPA with no server, so a cache lives in a Supabase Edge Function, not your React code. Here is how to add a Redis-compatible Valkey the right way.
TigerBeetle is purpose-built for double-entry financial accounting. Its own managed offering is invitation-only, but self-serve hosting now exists. The honest state of running it in 2026.
Supabase is a good product with a metered bill and a Postgres-only ceiling. Here is the honest shortlist of alternatives, what each one is actually for, and when you should just stay.
DuckDB is an analytics engine that runs inside your process, reads CSV, JSON and Parquet in place, and attaches PostgreSQL and MySQL as if they were local. Here is what it is good at, where it stops, and what changes when you host it.
Learn when to use full-text search, vector search, or both by running the same queries against Meilisearch and Qdrant side by side.
Build a social movie recommendation graph with SurrealDB and TypeScript, using one query language for documents, relations, and graph traversals without JOINs.
Prisma Postgres bills per operation, Neon bills per CU-hour, and Prisma frames the whole decision as a choice between those two meters. There is a third option: a flat plan with no meter at all. Here are the current Prisma numbers, the arithmetic for a chatty app, where operations pricing genuinely wins, and how to move with the direct TCP string.
Step-by-step migration from IBM Cloudant to a managed Apache CouchDB on Layerbase Cloud, with continuous replication for zero downtime, verification scripts, rollback plan, and notes on what does and does not transfer (design docs, Mango indexes, Cloudant Search, IAM keys, attachments).
A plain-language explanation of vector databases, how embeddings and similarity search power AI and RAG apps, when you need one, and where to spin one up.
Standalone DocumentDB 1.0 now runs on the Layerbase Free plan: 2 databases, 5 GB, no card. We measured its memory against PostgreSQL before moving it down from Solo.
libSQL has vector search built in: a vector column type, distance functions and an ANN index, no extension required. Here is how to keep rows and embeddings in one database, with the queries and the one gotcha to know.
A fair review of Cloud Clusters MariaDB hosting (maclusters.com) and an honest comparison with Layerbase Cloud: free tier, MariaDB version, branching, the web query console, and local tooling.
MariaDB shut SkySQL down in 2023, spun it out, then bought it back in 2025 and renamed it MariaDB Cloud. Here is what managed MariaDB hosting actually looks like now, and the options worth comparing.
Railway is a great place to ship an app and a usage-metered place to keep a database. Here is how to move your Railway Postgres, MySQL, or Redis to flat-priced managed Layerbase with one token.
Convex and Layerbase answer different questions. One is an integrated reactive backend, the other is managed hosting for standard databases you own. An honest comparison of reactivity, lock-in, pricing, and portability, with credit to Convex where it is due.
Build a filtered semantic search with Qdrant and local embeddings, then learn how to index payloads, version collections, and move the tested workflow to Layerbase Cloud.
A practical comparison of MySQL and MariaDB covering licensing, features, performance, and side-by-side TypeScript examples to help you pick the right one.
Build an application performance monitoring pipeline with InfluxDB 3 and TypeScript: line protocol writes, SQL and InfluxQL queries, windowed aggregations.
MongoDB announced an immediate CEO transition on September 28, 2026. Here are the confirmed facts and the practical questions for teams running MongoDB.
PlanetScale killed Hobby. Supabase free projects pause weekly. Redis Cloud free is 30 MB. Free tiers die because idle databases cost vendors real money. Ours does not, and that is the whole reason it can stay.
PostgreSQL is the right database for your SaaS MVP, and you probably will not need anything else for a long time. Here is why, and when to add Redis or search.
PostgreSQL 18 shipped with native UUIDv7, virtual generated columns, OLD/NEW in RETURNING, temporal constraints, skip scan, and zero-downtime NOT NULL.
There are three different things called "the Replit database", they behave differently, and only one of them is reachable from outside your Repl. Here is what each one is, why usage billing is an awkward shape for a side project, and when the built-in database is the right call anyway.
Lakebed is Theo Browne's new agent-native cloud for building full-stack TypeScript apps. It is a genuinely interesting idea, but it is not a database host. Here is an honest look at what it is, and why the Layerbase CLI is the better answer if you actually want a database.
Build instant, typo-tolerant search with Meilisearch and TypeScript. Learn why database queries fail on misspelled input and how Meilisearch fixes that fast.
Layerbase dedicated servers can now be placed in South America (São Paulo). Three flat-price sizes, every Layerbase Cloud engine on one single-tenant machine, and an honest account of what running in Brasil does and does not give you.
A step-by-step move from MongoDB Atlas to DocumentDB on Layerbase: the Network Access setting to change first, what the copy does and skips, how to check the result, and the branch you get at the end.
Heroku said in February 2026 that it is moving to a sustaining engineering model, with no pricing changes and no shutdown. Here is what that actually means for Heroku Postgres, where the Essential ladder stops working, and the honest list of alternatives including the case for staying.
Build a cache-aside layer and sliding session store with Valkey and TypeScript, then review expiration, invalidation, migration compatibility, and production tradeoffs.
Layerbase runs in the United States, Brazil and France, and none of them is near Asia. If your users are in Asia or the Middle East and what you need is Postgres, put the database near them. We recommend Nearbase for that, and here is how the two products split the work.
A fair review of Cloud Clusters MySQL hosting (sqlclusters.com) and an honest comparison with Layerbase Cloud: pricing, MySQL version, branching, web console, and local tooling.
Railway runs Postgres, MySQL, Redis and MongoDB as containers on a per-minute meter, which is cheap for one quiet database and less predictable once previews multiply. Two worked bills, how sleep and branching differ, and when keeping the database on Railway is the right call.
A sleeping database wakes on your next query, a paused project waits for a human to click Resume, and an archived one waits for you to ask for it back. The difference decides whether an idle week costs you three seconds or an afternoon of debugging the wrong layer.
Preview deployments that share one database quietly sabotage each other: migrations collide and seed data drifts. The Layerbase Vercel integration gives previews an isolated database branch with the connection string injected for you.
An honest review of Cloud Clusters SQL Server hosting (msclusters.com). If you are committed to SQL Server it is a reasonable, cheap option. If you are choosing a database fresh, here is why Postgres on Layerbase is worth a look.
Build an atomic fixed-window rate limiter and a real-time leaderboard with Redis and TypeScript, then learn the failure, durability, and production tradeoffs.
A fair review of Cloud Clusters Redis hosting (rclusters.com) and an honest comparison with Layerbase Cloud, which also offers Valkey and the VQueue queue platform: free tier, Redis version, branching, and local tooling.
Testing and CI pushed me to look at Lean, deterministic functional programming, and formal verification. The way of thinking reminded me of modeling in TypeDB.
A practical guide to understanding when your timestamped data needs a dedicated time-series database and when PostgreSQL is enough.
I gave Claude Code one API key. It created four databases in 38 seconds, used them, and let them delete themselves. The same loop works on the free plan, in CI, or in your next proof of concept.
Databricks closed its $1B acquisition of Neon and, surprisingly, made everything cheaper. Storage is down 80%, the free tier doubled. So why are people still searching for Neon alternatives?
Two things shipped together: transient databases that your CI can create with a TTL and never strand, and an installable skill that lets a coding agent provision, migrate, and advise on Layerbase from live facts instead of a price it half-remembers.
Spin up a libSQL database set up for the Better Auth schema, apply it in one click, then add email and password sign-in in a few lines. Local dev to production, same engine.
Build an inventory management system with MariaDB and TypeScript, covering core SQL plus features MySQL lacks like sequences and system-versioned tables.
prisma dev runs a local Postgres on PGlite with no Docker and no config, and it is right about the problem it picked. It also takes one connection at a time and only speaks Postgres. Here is what to run when your stack needs more than that.
Build a small MySQL blog backend with TypeScript, including foreign keys, transactional seed data, joined queries, full-text search, and production migration guidance.
A practical guide to when document databases like MongoDB make sense and when PostgreSQL with JSONB is the better choice.
Most managed Postgres platforms verify the server to you but never verify you to the server. Here is why Supabase, Neon, and PlanetScale cannot issue you a client certificate, why the architecture stops them, and how Layerbase does mTLS on a Postgres you can actually connect to.
A quick reference covering a selection of database engines available through the Layerbase CLI, what each one does, and when to pick it for your next project. over 20 engines, one cheat sheet.
Build a semantic article search with Weaviate and TypeScript, covering schema-aware collections, vector search, hybrid keyword-and-semantic search, and filters.
Build a small recipe search workflow with native MongoDB and TypeScript, including schema validation, nested queries, indexes, aggregation, and a safe path to FerretDB on Layerbase Cloud.
ReplDB is 5,000 keys behind one HTTP endpoint, and it is the smallest database plenty of shipped apps genuinely run on. What its ceilings cost you, how one paste moves the whole store into a managed Valkey, and when staying put is the right answer.
QuestDB 10.0.1 is now what a new QuestDB database on Layerbase runs. Here is what actually changed in 10.0, what stays the same when you connect, and what happens to databases already on 9.x (nothing).
Build a real-time web analytics pipeline with ClickHouse and TypeScript, from raw page view events to funnel analysis, all in one runnable script.
A step-by-step move of Heroku Postgres, and the Key-Value Store add-on, onto managed Layerbase databases. What comes across, what does not, why you must read DATABASE_URL fresh, and how to cut over without stopping your dynos.
People kept missing features we shipped, skipping the copy we sweated over, and leaving the site without telling us why. The good options were too expensive or too risky, so we built Filmroom, our own session replay tool. It is a standalone product at filmroom.dev now.
Most production apps need three or four databases. Buy each one from a specialist vendor and the minimums and meters stack into roughly $200 a month before you have meaningful traffic. Here is the math.
Build an e-commerce product catalog with FerretDB and TypeScript using the standard MongoDB driver, then see how your documents are really stored in PostgreSQL.
Compare persistent Agent Servers, Conductor workspaces, and T3 Code: where agents run, how task branches work, and what to expect from mobile access and review.
Run analytical queries on sales data with DuckDB and TypeScript, including rollups, window functions, and native PIVOT syntax that PostgreSQL cannot do.
A hands-on tour of Layerbase on video: moving off MongoDB Atlas and Supabase, preview branches for Vercel, MongoDB to PostgreSQL conversion, cross-database DuckDB queries, the CLI and desktop app, and a coding agent driven from a phone.
You added an instance, a webhook, a cache, a second server. Each was a normal Tuesday. Somewhere in there your app became several programs that disagree with each other. Here are the four failures that follow, and what each one looks like in your logs.
Flat pricing with no meters, 19 Cloud engines on one signup, branching beyond Postgres, a code-enforced never-lose-data guarantee, and six more things we do differently from the usage-billed incumbents.
Build a task management app with SQLite and TypeScript: JSON functions, window functions, recursive CTEs, and why the most deployed database is all you need.
PlanetScale MySQL is Vitess, sold as three-node clusters from $39 a month, with deploy requests that are still the best schema-change workflow around. Here is what Vitess changes about MySQL, how branching compares, two worked bills, and when PlanetScale is the right call.
A working order book in one TypeScript file on a local TigerBeetle: balances that cannot go negative, orders that lock funds without spending them, and trades that settle both sides or neither.
Postgres 19 adds REPACK, one command that replaces VACUUM FULL and CLUSTER and can shrink a bloated table without blocking writes. Here is how it works, where it falls short, and what else changed in 19.
EDB bought Altinity on November 5. Four days later ClickHouse said it was buying Xata. Two deals from opposite directions, one conclusion: vendors want to own both your transactional and your analytical database.
Electric joined Neon inside Databricks in August, and Electric Cloud is winding down with no published shutdown date. The sync engine stays open source. Here is what self-hosting it takes, and the Postgres checks to run before you move.
We tested Cloud Hypervisor and Firecracker side by side on lab hardware for two workload types, databases and Next.js apps, with every microVM restored from a snapshot. Here is what each one cost in wake time, tail latency, CPU and memory, and the two gotchas that bit us.











































































