Pinecone vs Weaviate vs Qdrant for Indie Hackers in 2026: Real Costs, Honest Verdict

Every AI feature you want to ship eventually hits the same question: where do the embeddings live? Semantic search, RAG over your docs, "related items" that actually understand content. All of it needs a vector database, and the three names you'll keep running into are Pinecone, Weaviate, and Qdrant.

My verdict upfront: for most indie hackers, Qdrant is the right default. The free tier is a real 1GB cluster that doesn't expire, the paid pricing is based on resources you provision instead of usage meters you can't predict, and the whole thing is open source, so the exit door is always open. Pick Pinecone if you want zero operations and the smoothest managed experience. Pick Weaviate if hybrid search and built-in embeddings matter to your product.

And before any of that: if your app already runs on Postgres, you might need none of them. More on that below.

Quick Verdict

Do You Even Need a Dedicated Vector Database?

Honest question first, because the vendors won't ask it. If your SaaS runs on Postgres, the pgvector extension adds vector similarity search to the database you already operate. It's what Supabase uses under the hood for its vector features, and below roughly 1 million vectors it performs fine for most workloads.

The advantages are boring and real. One database. One backup story. And you can join vector results against your relational data in a single query, which every dedicated vector DB makes you do in application code. When I add semantic search to a Laravel app, pgvector on the existing Postgres instance is where I start. It's one migration and an index, not a new service with its own SDK, billing, and failure modes.

You outgrow pgvector when you cross into millions of vectors, need consistently low latency under heavy filtering, or want features like built-in hybrid search and quantization. That's when these three enter the picture. My Convex vs Supabase vs Firebase comparison covers the backend side of this decision if you're picking the whole stack at once.

Pinecone

Pinecone is the managed option in the purest sense. Serverless indexes, no cluster to size, no HNSW parameters to tune. You write vectors to an API and query the same API. For a solo dev who wants the vector layer to be somebody else's problem, nothing here is easier.

The free Starter plan is genuinely usable: 2GB of storage, 2 million write units, and 1 million read units a month. That comfortably holds 100K vectors at 1536 dimensions (about 614MB) with real query traffic. Pinecone's own examples put a 50K-product recommendation engine at around 44K queries a day inside the free tier. The limits: AWS us-east-1 only, 5 indexes, 2 users, and indexes pause after three weeks of inactivity.

The quiet news is the new Builder plan: $20 a month flat, for solo developers and small teams. You get higher limits than Starter, your choice of cloud and region, and multiple projects. Best part: when you hit Builder's limits, usage is blocked rather than billed. That's a hard spending cap, which is exactly what a bootstrapper wants and exactly what usage-based platforms never offer. Most comparison posts haven't caught up to this tier existing.

Standard is where production apps land: a $50 per month minimum, then pay-as-you-go for reads, writes, storage, and egress beyond it. And this is Pinecone's honest downside. The unit economics are hard to predict. Reads are metered in "read units" that scale with namespace size and filtering complexity, so the same query costs more as your data grows. Write-heavy workloads, like agents that constantly update memory, hit the meters hardest. Nobody I know can estimate a Pinecone bill within 30% before shipping. The rates also vary by region, so run their pricing calculator with your actual numbers rather than trusting any blog's math, including mine.

Who should not use Pinecone: anyone allergic to usage-based billing, and anyone who wants a self-host escape hatch. Pinecone is closed source. If the pricing changes or the bill spikes, your only exit is a migration.

Weaviate

Weaviate is the maximalist. It's not just vector storage: hybrid search (BM25 keyword plus vector, fused), built-in embedding models billed per token, a Query Agent that turns natural language into database operations, and multimodal support. If you want one service to handle the whole retrieval layer, this is the pitch.

First, a correction to what you'll read elsewhere: Weaviate Cloud now has a permanent free tier. One cluster per user, 100,000 objects, 1GB memory, 10GB disk, and 2,000 embedding requests a day, free forever. The 14-day expiring sandbox that every early-2026 pricing guide warns you about is gone, and so is the old $25 Serverless tier and the $280 Plus tier. The current lineup is Free, Flex, and Premium. If a comparison post mentions the sandbox expiring, it's stale.

Flex is the paid entry point: a $45 per month minimum, pay-as-you-go, billed on three dimensions you can actually calculate: vector dimensions stored, storage in GiB, and backups. The math is refreshingly checkable. A million vectors at 1536 dimensions is 1.54 billion dimensions, which at Flex's base rate of $0.00465 per million dimensions comes to about $7 a month, far under the minimum. So from 100K to well past 1M vectors, your Weaviate bill is simply $45. That's a genuinely predictable number in a category full of surprise bills. Rates vary by region, index type, and compression, so treat these as the published baseline.

The built-in embeddings deserve a mention for solo devs: Snowflake Arctic models from $0.025 per million tokens, hosted inside the cluster. That removes a whole external API from your RAG pipeline, the way Lovable and friends removed the frontend boilerplate. Fewer moving parts matters more when you're the only engineer.

Who should not use Weaviate: pure vector search workloads on a budget. If all you need is "find the 10 nearest vectors," you're paying the $45 floor for hybrid search, agents, and vectorizers you won't touch, while Qdrant's free tier or pgvector does the same job for $0. The free tier's 100K object cap is also exactly at the edge of a modest RAG project, so budget for the jump to $45 the moment your dataset grows.

Qdrant

Qdrant is the one built like a tool rather than a platform, and that's a compliment. Rust core, open source under Apache 2.0, runs in a single Docker container. It sits next to a Laravel Sail stack as one more service in docker-compose.yml, which is the least dramatic way a new database has ever entered my development environment.

The cloud free tier is the best in this comparison: a permanent cluster with 1GB RAM, 4GB disk, and 0.5 vCPU, no credit card. With on-disk vector storage that stretches to roughly 1 million vectors at 768 dimensions, and a 100K-chunk RAG index at 1536 dimensions fits with room to spare. Two honest catches. Free clusters suspend after a week of inactivity and get deleted after four weeks, so a dormant side project can silently lose its index. And there's no high availability at this tier.

Paid pricing works the opposite way from Pinecone: you pay for the resources you provision (RAM, vCPU, disk), not per query or per write. Query traffic is free once the cluster exists. For read-heavy or write-heavy workloads, that flat cost curve is much easier to budget than metered units. The tradeoff is that you have to size the cluster yourself: vectors need to fit in RAM for fast search, so 1M vectors at 1536 dimensions means a cluster in the 8GB range uncompressed. Quantization is the lever here. Scalar quantization cuts RAM about 4x and binary up to 32x, which changes the bill dramatically. Qdrant doesn't publish flat per-GB prices; size your workload in their calculator before committing.

And the escape hatch is structural: the cloud runs the same Apache 2.0 software you can self-host. When your cluster bill crosses the cost of a beefy VPS, roughly the $100 a month mark, you can move the same collections to a Hetzner box and keep the same client code. That exit path is worth real money as leverage even if you never use it. It's the same logic that applies to leaving Firebase: open formats keep vendors honest.

Who should not use Qdrant: teams that want batteries included. There are no built-in embedding models comparable to Weaviate's (cloud inference for selected models exists, but it's narrower), no query agents, and hybrid search requires more assembly. You're also taking on cluster sizing decisions that Pinecone abstracts away entirely.

What Do They Actually Cost at Indie Hacker Scale?

Take a concrete workload: a RAG feature over 100K document chunks with 1536-dimension embeddings, about 614MB of raw vectors, with a few thousand queries a month.

All three run it for free. Pinecone's Starter covers it inside the 2GB limit. Weaviate's free tier fits it exactly at the 100K object cap. Qdrant's free cluster holds it with headroom. At true side-project scale, this category costs nothing in 2026, which was not true two years ago.

Now grow it to 1M vectors. Pinecone pushes you to Standard, $50 minimum plus unpredictable usage beyond it. Weaviate stays at a flat $45 on Flex, since the dimension charges are still only about $7. Qdrant needs a provisioned cluster: with quantization you're plausibly near the $45 to $50 of the other two, without it you're paying for 8GB of RAM and likely well past $100, or you self-host that RAM on a $50 VPS instead. At this scale the three converge on cost, and the decision flips to operations and features.

flowchart TD
    A{Already on Postgres or Supabase?} -- "yes, under ~1M vectors" --> B[Use pgvector, skip all three]
    A -- no, or outgrown it --> C{Want zero ops, no sizing?}
    C -- yes --> D[Pinecone]
    C -- no --> E{Need hybrid search or built-in embeddings?}
    E -- yes --> F[Weaviate]
    E -- no --> G[Qdrant]

How Do You Choose?

Choose on failure modes, not feature lists. Pinecone's failure mode is a surprise bill; its strength is that nothing else can fail because you operate nothing. Weaviate's failure mode is paying a platform floor for features you don't use; its strength is collapsing three services into one. Qdrant's failure mode is you making a bad sizing call; its strength is that costs are flat, the software is yours, and the free tier is the most generous.

So: prototype on whichever free tier matches your final choice, because migrations between vector databases are annoying enough that you won't do one for fun. If you can't decide, Qdrant's combination of a permanent free cluster and an open source exit is the option that keeps the most doors open.

Final Recommendation

Most solo devs and small teams should use Qdrant. Free at prototype scale, predictable when paid, self-hostable when big.

Use Pinecone if you want the vector layer fully off your plate and your workload is read-light enough that the meters won't bite. The $20 Builder cap is a nice bridge. Use Weaviate if hybrid search or built-in embeddings replace real work in your product; the flat $45 Flex bill up to surprisingly large scale is underrated.

And if you're on Postgres with a modest dataset, use pgvector and ship the feature this afternoon. The best vector database is often the one you already run.

Building something with one of these? Tell me what the bill actually looks like on Twitter @devtoolpicks. Real numbers beat pricing pages.