DEV Community: DevToolsPicks

Mintlify vs GitBook vs Docusaurus for Indie Hackers in 2026: Which Docs Tool Wins?

DevToolsPicks — Fri, 24 Jul 2026 04:30:07 +0000

Originally published at devtoolpicks.com

These three tools look like competitors and are really three different bets.

Mintlify sells polish. GitBook sells a visual editor your marketing person can use. Docusaurus sells total control for the price of your own time. Which one wins depends less on features than on who's writing the docs and what your budget looks like.

The pricing picture also just moved. Around June 2026, Mintlify restructured into two tiers: a free Starter plan and a custom Enterprise plan, with AI usage metered as credits. The old Pro and Growth tiers, which various sources reported anywhere from $150 to $550 a month, are gone from the pricing page. Most comparison articles you'll find haven't caught up. Meanwhile GitBook still charges per site and per user, and Docusaurus is still free and still asks for your weekend.

Here's how they actually compare for a solo founder.

Who is writing your docs?

Answer this first and the decision mostly makes itself.

If it's you, in your editor, alongside code, then a Git-based tool wins and the visual editor is a feature you'll never open. Docusaurus and Mintlify both fit.

If it's a non-technical teammate who will never open a pull request, GitBook exists for exactly that person, and its price is the price of that convenience.

If it's an open-source project with drive-by contributors, Docusaurus wins outright, because contributors already know how to submit a Markdown PR and hosting is free on GitHub Pages.

Quick verdict

Tool	Best for	Price	Rating
Mintlify	Polished API docs, best free tier now	Free Starter. AI credits metered, packs from ~$100/mo	4.6/5
GitBook	Non-technical editors, visual editing	Free (subdomain only). $65/site/mo + $12/user	3.9/5
Docusaurus	Open source, full control, zero cost	Free, MIT. Hosting $0 to $20/mo	4.5/5
Astro Starlight	Modern, faster alternative to Docusaurus	Free, MIT	4.4/5

Mintlify: the best free tier now, with a catch

Mintlify is the one that got dramatically cheaper this year. It's a docs-as-code platform where content lives in your Git repo as MDX, deploys through CI, and comes out looking better than anything you'd build yourself in a weekend. Anthropic, Cursor, Resend, and Clerk use it, which tells you the ceiling on output quality.

The June 2026 restructure is the headline. Starter is free and includes the editor, a custom domain, authentication, the AI assistant, the writing agent, automations, and an MCP server, plus 5,000 AI credits. A free custom domain alone puts it ahead of GitBook, which charges $65 a month for that single feature.

The catch is the credits. AI usage is metered at roughly 23 credits per assistant answer and around 115 per editor agent run, so 5,000 credits covers somewhere around 200 assistant interactions in an average month. Paid credit packs start around $100 a month for roughly 10,250 credits and climb to $1,000, with overages at a cent per credit. Real usage varies wildly: one reported case burned the full 5,000 on just 98 interactions.

Who should not use Mintlify: anyone whose docs will get heavy AI assistant traffic on a tight budget, since that's exactly where the metered model bites and the cost becomes unpredictable. SSO, role-based permissions, and SLAs are Enterprise-only with custom pricing. And you're on a hosted platform with a proprietary rendering layer, so leaving means a migration rather than a redeploy.

GitBook: you pay for the visual editor

GitBook is the tool your non-technical colleague can actually use. It pairs a genuine WYSIWYG editor with Git sync, so writers work visually while the content stays in a repo. For a team where a product marketer owns half the docs, that's worth real money.

It costs real money. GitBook's own pricing page lists site plans from $65 per site per month for Premium and $249 for Ultimate on annual billing, plus $12 per user per month. Both axes scale independently. A five-person team on one Premium site is around $125 a month rather than the $65 on the tin, and a ten-person team on two sites climbs past $300. Readers are free on public sites, so your audience doesn't drive the meter, only your editors do.

The free tier exists but publishes only to a gitbook.io subdomain. The moment you want docs.yourproduct.com, you're at $65 a month minimum.

Who should not use GitBook: solo developers. You'd be paying $65 a month for a visual editor you don't need and a custom domain that Mintlify now gives away. The per-site model also punishes anyone running docs for two products. Worth knowing: GitBook does publish an open-source repo you can self-host, but their own docs warn that updates may break it and they offer no support, so treat that as an escape hatch rather than a plan.

Docusaurus: free, and genuinely good

Docusaurus is Meta's static site generator for documentation, MIT licensed, and used by React Native, Redux, Supabase, and Snapchat. It's React under the hood, content is Markdown or MDX, and versioning and i18n are built in rather than bolted on. Hosting is free on GitHub Pages, or effectively free on Netlify and Vercel.

For an open-source project this is close to unbeatable. Contributors already know the workflow. Algolia's DocSearch is free for qualifying open-source docs, so you get good search without paying for it.

Let me push back on something you'll read elsewhere. Several hosted-docs vendors claim Docusaurus costs 10 to 20 hours a month in maintenance, translating to thousands in labor. That's marketing. For a small docs site, the real burden is occasional dependency updates and the odd build break after a major version, which is a few hours a quarter, not twenty a month. The number gets big only for large, heavily customized sites with bespoke React components.

Who should not use Docusaurus: teams with non-technical writers, and anyone who wants docs live this afternoon. There's no visual editor, no analytics dashboard, no AI search out of the box, and a contributor who doesn't know Git can't contribute. Real customization means writing React. Initial setup and theming is a genuine chunk of work, and you own every upgrade forever.

What about Astro Starlight?

Worth knowing before you default to Docusaurus. Starlight is Astro's documentation theme, also free and MIT licensed, and it's become the main modern alternative. It ships less JavaScript to the browser than a React-based Docusaurus site, which means faster pages, and setup is generally lighter.

The trade is maturity. Docusaurus has more plugins, more Stack Overflow answers, and a longer track record. If your team already works in Astro, or you care about shipping minimal JS, Starlight is the better pick. If you want the safest, most documented path, Docusaurus still is. Both cost nothing.

What about API reference docs?

If you're documenting an API, this is the section that decides it, because generating a reference by hand is miserable and nobody keeps it in sync.

Mintlify is built for this. Point it at an OpenAPI spec and it generates the reference pages, complete with an interactive playground where readers can fire real requests and see responses. Because the spec lives in your repo, the reference regenerates when the spec changes, which is the only version of API docs that stays accurate. This is the main reason API-first companies pick it.

GitBook handles OpenAPI too, syncing from a spec to produce reference pages, and its AI agent can keep those in sync. It's competent rather than exceptional, and you're paying at least $65 a month for the site before you get there.

Docusaurus needs a plugin. The community docusaurus-plugin-openapi-docs generates reference pages from a spec and works well, but it's a third-party dependency you now own: it can lag behind Docusaurus major versions, and configuring it is an afternoon rather than a checkbox. Starlight has a similar community story.

The honest summary: if API reference is the point of your docs, Mintlify saves you the most work by a wide margin. If your docs are guides and conceptual content with a small reference section, the gap narrows a lot.

Head-to-head on what matters

Price. Mintlify wins now, and it isn't close: free Starter with a custom domain against GitBook's $65 a month for the same capability. Docusaurus and Starlight are free but cost your time. The variable to watch on Mintlify is AI credits, which is the one place its bill can surprise you.

Editing experience. GitBook wins clearly. It's the only one here where a non-technical person can write, format, and publish without touching Git. That's its entire reason to exist and it does it well.

Output polish. Mintlify. The default theme, API playground, and search feel finished in a way that takes real effort to match with Docusaurus, and it shows in who uses it.

Control and lock-in. Docusaurus and Starlight. Your docs are Markdown files in your repo, rendered by an open-source generator you can fork. Moving hosts is a redeploy. Leaving Mintlify or GitBook is a migration.

Search. Mintlify includes AI search on the free tier. Docusaurus needs Algolia DocSearch, free for qualifying open-source projects and otherwise a paid dependency. If you're weighing that, our Algolia alternatives guide covers cheaper search backends including self-hosted Meilisearch and Typesense.

View the interactive diagram on devtoolpicks.com

What does this actually cost?

Take a solo founder with one product, one docs site, a custom domain, and moderate traffic.

Mintlify: $0. Starter covers the custom domain and the platform, and 5,000 monthly AI credits handle light assistant usage. If your docs get popular and users hammer the AI assistant, budget the first credit pack at around $100 a month.

GitBook: $65 a month, or $780 a year, purely to get off the gitbook.io subdomain. Add a second editor and it's $77.

Docusaurus or Starlight: $0 in software. Hosting is $0 on GitHub Pages or a free Netlify or Vercel tier, and realistically up to $20 a month if you outgrow those. Add a weekend of setup and a few hours a quarter after that.

Now add a teammate and a second product. GitBook goes to roughly $142 a month for two sites plus one extra seat. Mintlify stays free unless credits run out. Docusaurus stays free and costs another setup weekend.

The pattern: GitBook's bill scales on two axes at once, which is why it's the one people write angry posts about.

The verdict

For most indie hackers in 2026, Mintlify is the pick, and that's a change from what I'd have said six months ago. The free Starter tier now includes the custom domain and the AI assistant that used to sit behind a $150-plus plan, and the output looks better than anything you'll hand-roll quickly. Just watch the credit meter if your docs get busy.

If you're running an open-source project, or you want your documentation to be plain Markdown in your own repo with no vendor at all, use Docusaurus. It's genuinely excellent, the "hidden maintenance cost" scare stories are overstated by people selling alternatives, and free means free. Pick Starlight instead if you're already in Astro or you want the faster, lighter build.

GitBook is the narrow one. It's a good product solving a specific problem: letting non-technical people edit docs visually while keeping Git sync. If that's your situation, it earns the money. If it isn't, you're paying $65 a month for a custom domain that a competitor now gives away free, and the per-site plus per-user model gets worse as you grow.

If you're setting up the rest of the site, our Vercel alternatives guide covers where to deploy a static docs build, Astro vs Next.js vs Eleventy goes deeper on the generator underneath Starlight, and GitHub alternatives is worth a look if you're rethinking where the repo itself lives.

Best Contentful Alternatives for Indie Hackers in 2026 (After the Salesforce Deal)

DevToolsPicks — Thu, 23 Jul 2026 04:20:09 +0000

Originally published at devtoolpicks.com

Two things changed for Contentful customers this year, and both point the same direction.

The first is pricing, which has been the complaint for a while. Contentful has a free tier covering roughly 10 users, 100,000 API calls a month, and 50GB of CDN bandwidth. Past that, the first paid tier lands around $300 a month. There's nothing in between. No $29 plan, no $79 plan. A side project that outgrows the free limits goes from paying nothing to paying more than most indie hackers make from the product. Third-party trackers cite anywhere from $300 to $850 for that same tier depending on billing cycle and configuration, which tells you how much the real number moves.

The second is bigger. On June 1, 2026, Salesforce announced a definitive agreement to acquire Contentful. Both companies confirmed it. The deal is expected to close in the third quarter of Salesforce's fiscal 2027, subject to regulatory approval, and until then Contentful keeps operating under its current platform and terms. But if you're choosing content infrastructure for the next three years, "this is becoming part of Salesforce's enterprise stack" is a real input.

Here's the short version. Payload and Strapi are MIT licensed and free to self-host. Sanity has the most generous hosted free tier if you don't want to run a server. Directus is the pick if you already have a SQL database. And if you build in Laravel, Statamic is free for a single user, forever.

Five alternatives below, with honest notes on where each one hurts.

What does the Salesforce deal actually change?

Less than the headlines suggest, at least for now.

The agreement was announced June 1, 2026 and has not closed. Salesforce says Contentful will continue with the same platform, APIs, and support model, with deeper Agentforce integration on the roadmap. Every "AI-assembled content" claim in the announcement is roadmap rather than shipped capability, so judge Contentful on the product it ships today, not the pitch deck.

What's worth weighing is direction. Contentful is being positioned as the content layer for Salesforce's enterprise stack. Historically, that kind of move tends to sharpen focus on large enterprise accounts, which is not where a solo founder sits. Nothing about your pricing changes tomorrow. It's the three-year view that shifts.

One more angle if you're in the EU, as I am. Contentful was founded in Berlin, and acquisition by a US corporation brings it under US jurisdiction including the CLOUD Act. Open-source advocates raised exactly this point for European public sector use. If data residency is a compliance requirement rather than a preference, self-hosting stops being an ideology and starts being a checkbox.

Quick verdict

Tool	Best for	Price	Rating
Payload	Next.js apps wanting CMS in the same codebase	Free, MIT. Cloud from $35/mo	4.7/5
Strapi	Biggest open-source ecosystem, self-hosting	Free, MIT. Cloud from ~$18/mo	4.6/5
Sanity	Hosted with no servers to run	Free (20 seats, 10K docs). Growth ~$15/seat/mo	4.6/5
Directus	Adding a CMS layer to an existing SQL database	Free self-host core. Cloud from $99/mo	4.3/5
Statamic	Laravel projects and marketing sites	Solo free forever. Pro one-time per site	4.5/5
Contentful	Enterprise content ops at scale	Free tier, then ~$300/mo	3.9/5

Payload: the CMS that lives inside your app

Payload went from relatively obscure to the default recommendation in Next.js communities, and the reason is architectural. It isn't a separate server you call over an API. It's a Node package that runs inside your own project, so Payload effectively becomes your backend. It connects to Postgres or MongoDB, generates an admin UI, and exposes REST and GraphQL.

For a solo founder building a product rather than a brochure site, that's a genuinely different shape. Your CMS content and your application data can live in the same Postgres instance. Authentication, collections, and business logic sit in one Node app. Content types generate full TypeScript types automatically, so nothing leaks through as any. Local development needs zero external services.

It's MIT licensed and free, so you pay only for infrastructure. Payload Cloud exists at around $35 a month for managed hosting. It also went framework-agnostic and now works with Remix, Astro, and SvelteKit rather than Next.js alone.

Who should not use Payload: teams that want a mature ecosystem. It's younger than Strapi, with fewer plugins, fewer tutorials, and fewer Stack Overflow answers when something breaks at 11pm. Self-hosting is the primary path, so you own infrastructure, scaling, and security from day one. And because the CMS lives inside your app, non-technical editors depend on you deploying changes, which is fine for a solo product and awkward for an agency with ten client sites.

Strapi: the biggest open-source ecosystem

Strapi is the most established open-source headless CMS, with over 72,000 GitHub stars and roughly 100,000 weekly npm downloads. It's MIT licensed, self-hosted by default, and the Community edition is free forever. Strapi v5 was a significant rewrite with better performance, a revamped content type builder, and stronger TypeScript support.

The plugin ecosystem is the real advantage. When you need SEO fields, preview, or a specific integration, someone has usually already built it. It's also a standalone API server rather than a package inside one app, which suits you when several frontends consume the same content, or when a client's marketing team needs to edit without touching your deploy pipeline.

Self-hosting on a VPS, Railway, or Render is free. Strapi Cloud starts around $18 a month for Essential and roughly $90 for Pro, priced per project, and a cheaper cloud entry tier arrived in late 2025.

Who should not use Strapi: anyone allergic to ops. The software is free, the operation isn't. Self-hosted Strapi means running and patching a Node server, a SQL database, and media storage, which realistically means $50 to $200 a month of infrastructure plus your time once it's a real production site. Strapi Cloud's per-project pricing also adds up if you run several small sites, where a per-seat model might work out cheaper.

Sanity: the most generous hosted free tier

If you don't want to run a server at all, Sanity is the pick. Your content lives in Sanity's Content Lake, queries run through GROQ over a CDN-backed API, and Sanity Studio is a React app you embed in your own repo. There's no infrastructure, no patching, and the managed asset pipeline handles on-the-fly image transforms, which is a genuine amount of work you don't have to do.

The free tier is the most generous in this comparison: up to 20 seats, 10,000 documents, and monthly AI credits. For a blog or a content-driven marketing site, plenty of teams never leave it. Growth is around $15 per seat per month after that, and real-time collaborative editing is a feature the self-hosted options don't match.

Who should not use Sanity: anyone who needs data ownership or self-hosting. There is no self-hosted option, so if GDPR data residency is a hard requirement, this is the wrong lane, especially ironic given it's the reason some people are leaving Contentful. Per-seat pricing is predictable for a small team but adds usage-based charges at scale, and GROQ is a query language you'll need to learn rather than the GraphQL you already know.

Directus: a CMS layer over the database you already have

Directus solves a different problem. Instead of asking you to model content in its own system, it wraps an existing SQL database and gives you an admin UI and instant REST and GraphQL APIs over your actual tables. If you already have Postgres or MySQL with real schema in it, this is the shortest path to a CMS.

The pricing has an unusual and genuinely indie-friendly wrinkle. Beyond the free self-hosted Core tier (3 seats, 25 collections, 5 Flows, AI assistant), Directus runs an Open Innovation Grant that makes self-hosting free for organizations under $5 million revenue and 50 employees. That covers essentially every reader of this blog. Directus Cloud starts around $99 a month, and the Team tier is roughly $499 a month billed annually.

Who should not use Directus: anyone who wants a polished editorial experience out of the box. Because it reflects your database schema, the editing UI is only as friendly as your table design, and non-technical editors often find it more raw than Sanity or Statamic. The jump from free Core to $499 Team is also steep, so read the grant terms carefully rather than assuming you qualify forever.

Statamic: the Laravel-native option

If you build in Laravel, Statamic deserves a serious look, and this is the pick I'd reach for personally. It's a Laravel-based CMS that can store content as flat files in YAML and Markdown or use a database, and its control panel is one of the best-looking admin interfaces in the category.

Flat-file storage is the interesting part. Your entire site, content included, lives in Git. Deployments are pushes, rollbacks are reverts, and content migrations are file diffs. No database sync problems between staging and production. You can use Antlers, Statamic's own templating language, or drop straight to Blade for full Laravel integration, and the Runway addon gives you Eloquent-powered relationships when you need database-backed models.

Pricing is refreshingly simple: the Solo license is permanently free for a single user and genuinely usable in production, not a trial. Pro is a one-time per-site license rather than a subscription, listed in the $259 to $349 range depending on which source you read, and includes a year of updates with roughly $99 a year after that if you want to keep updating. Confirm the current figure on Statamic's own pricing page.

Who should not use Statamic: anyone not on Laravel, and anyone with high-volume transactional content. Flat files are excellent for marketing sites and blogs and poor for e-commerce catalogs with thousands of SKUs or heavy user-generated content. Runway and the Eloquent driver handle that, but with more setup complexity. Pro pricing is also per site, so an agency running many client sites is buying many licenses.

How do you choose?

Match it to the shape of your project.

Building a product in Next.js or another JS framework: Payload. CMS and app in one codebase, one database, full TypeScript.
Need a standalone content API with a big plugin ecosystem: Strapi. The most mature open-source option.
Don't want to run servers: Sanity. The free tier is generous enough that many teams never pay.
Already have a SQL database with real schema: Directus. Check whether the Open Innovation Grant makes it free for you.
Building in Laravel: Statamic. Solo is free forever and content lives in Git.
Enterprise content ops with a real budget: stay on Contentful. It's mature for a reason.

View the interactive diagram on devtoolpicks.com

What does this actually cost?

Take a small marketing site plus a blog, one developer and one editor.

On Contentful, you're free until you cross the limits, then roughly $300 a month, which is $3,600 a year. That's the cliff. Nothing sits between free and that number.

On Sanity, the same setup fits comfortably inside the free tier, so $0, and even on Growth two seats is around $30 a month.

Self-hosted Payload or Strapi is the cost of a VPS. A $10 to $20 a month box handles a small site fine, though a busier production Strapi install with separate database and media storage realistically runs $50 to $200 a month once you size it properly. Call it $120 to $2,400 a year depending on scale, with no per-seat component at all.

Statamic Solo is $0 forever for one user. Pro is a one-time few hundred dollars rather than a recurring bill, which over three years is dramatically cheaper than any subscription here.

The pattern should be familiar by now: the open-source and one-time-license options have a flat cost curve, while the SaaS options bend upward with seats and usage. If you're pre-revenue, flat wins.

The verdict

For most indie hackers leaving Contentful, the honest answer depends on one question: do you want to run a server?

If yes, self-host. Payload if you're building a product in JavaScript and want the CMS inside your app. Strapi if you want a standalone API and the biggest plugin ecosystem. Both are MIT licensed with no per-seat cost ever, which is the whole point.

If no, Sanity. Its free tier is the most generous in the category, it removes an entire class of operational work, and $15 a seat is reasonable when you outgrow it. Just know you're accepting the same hosted-vendor dependency that made Contentful uncomfortable.

If you build in Laravel, Statamic. Solo is free, content lives in Git, and Blade means no new templating layer. That's my pick.

And to be fair to Contentful: it's a mature platform with genuinely good content modeling and multi-environment management, and it isn't going anywhere before the deal closes. If you're an enterprise team with a budget, none of this applies. If you're a solo founder staring at a $300 wall while your CMS gets absorbed into a CRM suite, there are five better options above.

If you're rebuilding the rest of the stack, our Next.js vs Nuxt vs SvelteKit comparison covers the frontend, Vercel alternatives covers where to deploy it, and Supabase alternatives covers the database underneath. For simple marketing sites where a headless CMS is overkill, Framer vs Webflow vs Carrd is the better starting point.

Best Customer Feedback Tools for Indie Hackers in 2026 (Free and Cheap Picks)

DevToolsPicks — Tue, 21 Jul 2026 04:15:08 +0000

Originally published at devtoolpicks.com

Here's the thing about most customer feedback tools: they charge you more as more people give you feedback.

Canny, the category leader, bills by tracked users. Anyone who submits, votes, or comments counts. The free plan caps at 25 of them, which an embedded widget can burn through in an afternoon. Core starts around $19 a month billed annually for 100 tracked users, but push into a few thousand and the same plan climbs into the hundreds. Run a growth campaign, get more engagement, pay more. The pricing model quietly penalises the exact thing you're trying to make happen.

For a solo founder with 200 users and no revenue, that's backwards.

The good news is this category has real free options. UserJot gives you unlimited end users on a free plan. Featurebase has a startup discount that's genuinely aggressive. Fider and ClearFlask are open source. And if your users are developers, you might already have everything you need in GitHub.

Six options below, with honest notes on where each one breaks.

What are you actually trying to do?

Two different jobs get sold as the same product.

The first is a public feedback board: users post ideas, other users vote, you mark things planned or shipped, and everyone can see what's coming. That's the classic Canny shape, and it's what most indie hackers want.

The second is a support and feedback suite: help centre, live chat, ticketing, AI agent, plus the board. That's where Featurebase has moved, and it's genuinely useful if you're drowning in support email. It's overkill if you just want a roadmap page.

Know which one you're buying before you compare prices, because the per-seat suites look expensive next to a simple board for good reason.

Quick verdict

Tool	Best for	Price	Rating
UserJot	Best free plan, unlimited voters	Free (2 boards, unlimited users)	4.6/5
Featurebase	Feedback plus support in one tool	Free (1 seat). Paid from $29/seat/mo	4.5/5
Fider	Self-hosting, full data ownership	Free, open source	4.3/5
Canny	Polished incumbent, best integrations	Free (25 tracked users). Core ~$19/mo	4.2/5
Nolt	Flat pricing, unlimited voters	From $29/mo per board. No free plan	3.9/5
GitHub Discussions	Developer audiences, zero cost	Free	4.0/5

UserJot: the strongest free plan

UserJot is the pick if "free" is the requirement and you don't want to run a server. Its free plan gives you two boards, unlimited end users, and no watermark, which is a meaningfully better deal than anything else hosted here. The whole positioning is anti-per-seat: your voters are never a billing event.

For a solo founder that's the right shape. You embed a board, users vote, and growth in engagement doesn't generate an invoice.

Who should not use UserJot: teams that need a deep integration stack or an established track record. It's a newer, smaller product than Canny or Featurebase, so the integration list and ecosystem are thinner, and pricing information has been awkward to find on their site. If you need Jira or Salesforce wiring and enterprise support, look at the incumbents. Check the current free-plan limits before you build on them, since young products change terms more often than mature ones.

Featurebase: feedback and support in one

Featurebase has grown from a feedback board into an all-in-one product and support platform: feature boards, roadmap, changelog, surveys, help centre, live chat, and an AI support agent called Fibi. Every plan includes both suites, so you're not paying separately for the support half.

Pricing is per seat, where a seat is an admin who manages feedback or answers support, not a customer. There's a free tier for one seat, and paid plans run roughly $29, $59, and $99 per seat per month on annual billing. The number that matters for indie hackers is the Startup Program: companies under about two years old can get the Professional plan at roughly 86% off, which works out near $8 a seat.

Who should not use Featurebase: anyone who only wants a voting board. You'd be buying a support suite you don't use. Two costs are easy to miss: every paid plan charges $0.29 per AI resolution, so a busy AI agent creates a real variable bill, and removing "Powered by Featurebase" branding costs around $69 a month and only on the higher tiers. Per-seat pricing also scales linearly, so five admins on the mid tier is roughly $145 a month at list.

Fider and ClearFlask: the open-source route

If you'd rather own the data, this category has genuine open-source options. Fider is the best known: a clean, proven feedback board you can run with Docker, covering the core loop of posting, voting, and status updates. ClearFlask is the more featured option, Apache 2.0 licensed, with a JavaScript widget, custom domains, private boards, and SSO. ClearFlask's own pricing page states plainly that self-hosting is free and includes all functionality, with paid licenses existing only for support.

The appeal is the same as everywhere else in this stack: your feedback lives in your database, costs scale with compute rather than seats, and nobody can reprice you. Canny moved from per-admin to tracked-user billing in 2025, which is exactly the risk self-hosting removes.

Who should not self-host: anyone without the appetite to run another service. Fider is simple but basic, so you'll miss changelogs and richer integrations. ClearFlask is the opposite problem: powerful but genuinely complex to operate, with a Java API server, a Node layer, and a modular storage setup spanning MySQL or Elasticsearch, DynamoDB, and S3 or MinIO. That's a lot of moving parts for a feature-request board. LogChimp and Astuto are smaller alternatives, with the maintenance risk smaller projects carry.

Canny: the polished incumbent

Canny is still the most refined product in the category, and it's worth being fair about that. The interface is clean, the integration list is the deepest here (Slack, Intercom, Jira, GitHub, Linear, Salesforce), and every plan includes a public roadmap and changelog with unlimited posts and boards. If you want the thing that just works and looks right, this is it.

The free tier covers 25 tracked users and five managers. Core is around $19 a month billed annually ($24 monthly) for 100 tracked users, and Pro is around $79 a month annually ($99 monthly). Canny does let you set a monthly spending limit, which blunts the worst surprise.

Who should not use Canny: anyone whose user base is growing fast on a small budget. The tracked-user model means your cost tracks engagement, and the jump from free to useful is steep. At around 1,000 tracked users, Core reportedly lands near $311 a month, which is real money for a pre-revenue product. The free plan works as an extended trial rather than a tier you can live on.

Nolt: flat pricing, no free plan

Nolt does one job cleanly: a single public board where people post ideas and vote. Pricing is flat per board, around $29 a month for Essential (one board) and $69 for Pro (five boards), with a 20% annual discount. Critically, voters and content are unlimited on every plan, so unlike Canny your bill doesn't move when engagement does. The integration list is solid, with Jira, Linear, Monday, and Asana on Pro.

Who should not use Nolt: anyone who needs a free tier or a changelog. There's no permanent free plan, just a short trial, and there's no changelog or embeddable widget. Per-board pricing also multiplies if you run several products. The product has seen relatively few updates recently, so factor that into a long-term bet.

Do you need a feedback tool at all?

If your users are developers, probably not yet.

GitHub Issues and Discussions cover the loop surprisingly well. Reactions work as votes, labels work as statuses, a public Project board works as a roadmap, and Discussions gives you threaded conversation. It costs nothing, adds no vendor, and your audience already has accounts, which removes the biggest friction in any feedback tool: getting someone to sign up just to complain.

This is the same reasoning that makes Laravel Pennant a better feature flag pick than a SaaS for most solo founders. Use what you already have until it genuinely stops working.

It stops working when your audience isn't technical, when you need an in-app widget so people can submit without leaving your product, or when you want a changelog that emails subscribers. That's the moment to pay.

One more honest point: before product-market fit, most real feedback doesn't arrive on a board at all. It comes from support email, direct conversations, and communities. Our GummySearch alternatives guide covers the Reddit-listening side of that, which is often more useful early than a voting page nobody has found yet.

How do you choose?

You want free and hosted: UserJot. Two boards, unlimited voters, no watermark.
Your users are developers: GitHub Discussions with a Project board. Free, zero setup.
You want feedback and support together: Featurebase, especially if you qualify for the startup discount.
You want to own the data: Fider for simple, ClearFlask if you need the features and can run the infrastructure.
You want the most polished product and can afford it: Canny.
You want flat, predictable pricing with unlimited voters: Nolt.

View the interactive diagram on devtoolpicks.com

The verdict

For most indie hackers, start free and stay free longer than you think. If your users are developers, GitHub Discussions plus a public Project board does the job at zero cost and zero setup. If they're not, UserJot's free plan is the best hosted option because unlimited end users means the tool never punishes you for growing.

Once you have real usage and real support volume, Featurebase is the best paid pick, especially with the startup discount, because you replace two tools instead of one. Canny is the nicest product in the category and the right call if polish and integrations matter more than the bill, but the tracked-user model is a genuine trap for a growing product on a small budget. Nolt is the pick if you specifically want flat pricing with unlimited voters and don't need a changelog.

The pattern is the same one that runs through most of this stack: per-user pricing punishes success. Pick the tool whose bill doesn't move when your product works.

If you're building out the rest of your product feedback loop, our Hotjar vs Microsoft Clarity vs PostHog comparison covers session replay and behaviour, and PostHog vs Plausible vs Fathom vs Mixpanel covers the analytics side that tells you whether the requested feature actually got used.

Best Retool Alternatives for Indie Hackers in 2026 (Free and Self-Hosted Picks)

DevToolsPicks — Mon, 20 Jul 2026 04:05:09 +0000

Originally published at devtoolpicks.com

Retool is genuinely good software. That is not the problem.

The problem is that it bills you three different ways at once. Retool splits users into builders who create apps, internal users who only open them, and external users outside your organization, and each class is priced separately. The Business plan runs $65 per builder per month month-to-month, or $50 if you pay annually. SSO lives on that tier, so any team with a compliance requirement absorbs the jump from Team, which sits around $10 per builder. The free plan covers up to 5 users, which is fine until your ops person and your co-founder both want logins.

For a solo founder who wants an admin screen to refund an order and edit a user record, that is a lot of pricing machinery.

Here's the short version. If you build in Laravel, you almost certainly don't need any of this: Filament does the job free, inside the app you already have. If you're not on Laravel, Appsmith, ToolJet, and Budibase are all open source and free to self-host with no seat caps.

Four alternatives below, plus an honest note on when staying with Retool is the right call.

What are you actually building?

Worth being precise, because it changes the answer completely.

Most indie hackers who search for this want an admin panel: a screen over their own database to view users, fix bad records, issue refunds, and flip a flag. That's a solved problem, and your framework probably solves it already.

A smaller group wants an internal tool platform: a drag-and-drop builder where a non-technical teammate can assemble their own dashboard from five different data sources without asking you. That's what Retool sells, and it's a real category worth paying for when you actually need it.

If you're in the first group, skip to the framework-native section. You'll save yourself a subscription and a second copy of your database credentials.

Quick verdict

Tool	Best for	Price	Rating
Laravel Filament	Laravel apps that want an admin panel free	Free, MIT licensed	4.8/5
Appsmith	JavaScript-heavy teams wanting code control	Free self-host. Cloud free to 5 users, then $15/user/mo	4.5/5
ToolJet	Cheapest credible cloud tier	Free self-host, no user caps. Cloud from ~$19/builder/mo	4.4/5
Budibase	Non-technical teammates building CRUD apps	Free self-host. Cloud pricing varies, verify current	4.2/5
Retool	Deep integrations, non-technical builders at scale	Free to 5 users. Team ~$10/builder, Business $50 to $65	4.0/5

Laravel Filament: the one you already have

If you build in Laravel, start here and you may well stop here. Filament is a free, MIT-licensed UI framework built on the TALL stack (Tailwind, Alpine.js, Livewire, Laravel), with around 29,000 GitHub stars and the deepest plugin ecosystem of any Laravel admin package. There's no license to buy and no per-seat anything.

The workflow is the appeal. You define a resource as a PHP class pointing at an Eloquent model, and Filament generates the table with sorting, filtering, and bulk actions, plus forms with 50-plus field types, relation managers, widgets, and a dashboard. Because it reads your models directly, it already knows your relationships and validation rules. There's no second system holding a copy of your database credentials, no data leaving your server, and no connector to configure.

I run the DevToolPicks admin on Filament, which is why scheduling a post is a two-minute job rather than a deploy.

Cost is nothing beyond the app you already run.

Who should not use Filament: anyone not on Laravel, obviously. Beyond that, it's developer-first. A non-technical teammate can use the panel you build, but they can't build their own without you writing PHP, which is exactly the gap Retool fills. Customization also means learning Filament's own conventions and Livewire component architecture, so it's a second layer of knowledge on top of Laravel rather than a pure drag-and-drop tool.

Worth knowing the neighbours: Laravel Nova is the official paid option from the Laravel team, and Backpack has been around since 2016 with a free core. Filament is free and has the most momentum, so it's the default in 2026.

Appsmith: open source for JavaScript teams

Appsmith is the closest open-source equivalent to Retool for developers. It's Apache 2.0 licensed with roughly 40,000 GitHub stars, and that license matters: you can fork it, self-host it, and modify it without the relicensing questions an AGPL project raises. Self-hosting removes the user cap entirely.

The pitch is JavaScript everywhere. Every widget, query, and data transformation can run through JS, and Git integration is native, so your internal tools live alongside your codebase and go through normal review. It connects to 25-plus data sources, covering the usual SQL databases plus REST and GraphQL.

On pricing, the cloud free tier covers up to 5 users with 5 workspaces and 3 Git repos. Business is $15 per user per month for up to 99 users and adds unlimited workspaces and repos, audit logs, custom roles, and branding removal. Enterprise starts at $2,500 a month for 100 users. The old hourly usage meter is gone, replaced by the flat per-user rate.

Who should not use Appsmith: non-technical teams. Everyone agrees on this point, including Appsmith's own positioning. If your team doesn't write JavaScript, they will struggle, and Budibase is the friendlier choice. Self-hosting also means you own the Docker deployment, upgrades, and backups. And note that private app embedding sits behind Enterprise, so client-facing embeds get expensive.

ToolJet: the cheapest credible cloud tier

ToolJet sits between the other two. It's AGPL-3.0 licensed with around 37,000 GitHub stars, and the community edition self-hosts free with no user limits, which is the headline for cost-conscious founders. The cloud tier is the cheapest of the credible options, starting at roughly $19 per builder per month, well under Retool's Business plan.

Where it differentiates is language support and setup. You get a visual drag-and-drop builder, but JavaScript and Python are both available when the visual layer runs out, which is unusual in this category. Users generally find self-hosting more straightforward than Appsmith's, and role-based access controls appear on lower tiers than Appsmith gates them behind. It also added AI app generation, where you describe the tool and it scaffolds it, though that feature is still rough.

Who should not use ToolJet: teams that need everything polished. Several features feel less finished than Appsmith's equivalents, and large datasets can make the builder sluggish. The AGPL license is also stricter than Appsmith's Apache 2.0, which matters if you plan to modify and redistribute. Published cloud pricing has moved around and third-party sources disagree, so check the current numbers on ToolJet's own pricing page before you commit.

Budibase: the one non-developers can actually use

Budibase takes the opposite approach to Appsmith. Instead of putting code everywhere, it tries to keep you out of code entirely. Point it at a SQL schema and it auto-generates CRUD apps, and it ships a built-in database so you can start without an external data source at all. It's GPL v3 licensed and self-hosts free.

That makes it the right pick when the person building the tool isn't you. If your ops teammate or co-founder needs to spin up their own screen over an existing table, Budibase gets them there fastest of anything here. SSO and role-based access control are included rather than gated behind an enterprise tier, which is genuinely unusual.

Who should not use Budibase: anyone who needs deep customization. The trade for that speed is a ceiling. Once your tool needs unusual logic or a custom component, you'll hit the edge of the visual builder sooner than with Appsmith or ToolJet. Its cloud pricing has also changed and public sources contradict each other, with reports that the cloud free tier was withdrawn for new signups, so treat the self-hosted edition as the reliable free path and confirm cloud pricing directly.

What does this actually cost at three people?

Per-seat pricing sounds harmless until you run the numbers on a realistic small team: two developers building tools and one non-technical person using them.

On Retool Business, both builders bill at $50 each with annual billing, or $65 month-to-month. That's $100 a month annually, $130 monthly, before the internal user and before any AI credit overage. Call it $1,200 a year at the friendly end. On Retool Team at around $10 per builder you'd pay far less, roughly $20 a month, but SSO isn't there, which is the reason most teams end up on Business in the first place.

Appsmith Business at $15 per user puts the same three people at $45 a month, about $540 a year. ToolJet's cloud at roughly $19 per builder lands near $38 a month for the two builders.

Self-hosted, all three cost the same thing: a VPS. A $10 to $20 a month box on Hetzner or DigitalOcean runs Appsmith, ToolJet, or Budibase comfortably for a small team, with no seat limits at all. That's $120 to $240 a year, flat, regardless of how many colleagues you add.

Filament costs nothing at all, because it runs on the server your app is already running on.

The honest caveat on self-hosting: the license is free, your time isn't. Budget a few hours for the initial Docker setup and a recurring hour here and there for upgrades and backups. If that time is worth more to you than the difference, the managed tier is a legitimate choice rather than a failure of nerve.

Do you need a platform at all?

Before you install any of the above, check what your framework already gives you. This is the same logic that makes Laravel Pennant a better feature flag choice than a SaaS for most solo founders.

Laravel has Filament, Nova, and Backpack. Django ships an admin out of the box that generates CRUD screens straight from your models. Rails has ActiveAdmin and Administrate. All of them read the models you've already written, which means your validation rules, relationships, and authorization policies come along for free instead of being re-implemented in a separate platform.

There's a security argument too. Every external tool builder needs credentials to your production database. A framework-native admin runs inside the app that already has them. One fewer place to leak from, one fewer vendor in your compliance story.

The honest limit: this only works if the people who need tools are developers. The moment a non-technical teammate wants to build rather than use, you want a real platform.

View the interactive diagram on devtoolpicks.com

When is staying on Retool the right call?

Worth saying plainly, because a post like this can drift into pretending the incumbent has no case.

Retool has the deepest component library and the widest set of native connectors of anything here, covering PostgreSQL, MySQL, MongoDB, REST, GraphQL, Snowflake, BigQuery and dozens more. If your internal tools pull from six systems at once, replicating that in an open-source builder is real work. Its mobile support is stronger than the alternatives, and if you're a funded team where a dozen non-technical people build their own tools daily, $50 a builder is cheap next to the engineering time it saves.

The case falls apart for solo founders and small teams, which is most people reading this. That's the whole argument.

The verdict

If you build in Laravel, use Filament. It's free, it lives inside your app, it reads the models you already wrote, and it removes an entire vendor from your stack. For most readers of this blog that's the end of the decision.

Not on Laravel? Check your framework's admin layer first, then reach for an open-source platform when you genuinely need non-developers building their own tools. Appsmith if your team writes JavaScript and wants Git-backed control. ToolJet if you want the cheapest cloud tier or need Python. Budibase if the builders aren't developers at all.

The common thread with Retool is the same one that shows up across this whole category: per-seat pricing punishes you for having colleagues. Every option here breaks that link by self-hosting free or living inside code you already own. Start with the one that matches your stack, and only pay when a tool is doing something your framework genuinely can't.

If you're auditing the rest of your stack while you're here, our Supabase alternatives guide covers the backend side, Laravel Forge vs Ploi vs Coolify covers where to run all of it, and Notion alternatives covers the docs-and-wiki layer.

Vitest vs Jest vs Bun Test for Indie Hackers in 2026: Which Should You Use?

DevToolsPicks — Fri, 17 Jul 2026 04:45:15 +0000

Originally published at devtoolpicks.com

If you're picking a test runner for a JavaScript or TypeScript project in 2026, the honest answer is short: use Vitest unless you have a specific reason not to.

Jest ran the show for a decade. It shipped with Create React App, it's baked into NestJS and countless boilerplates, and its ecosystem is still the deepest in the space. But the JavaScript world moved to ES Modules and Vite, and Jest's CommonJS-first roots started to show. Vitest was built for the new world: native ESM, TypeScript with no ts-jest layer, and a watch mode that reruns affected tests in milliseconds. Meanwhile Bun ships its own test runner that beats both on raw execution speed, if you're willing to live inside the Bun runtime.

So the real decision comes down to three questions: what's your stack, how much does watch-mode speed matter, and do you ship to React Native. Here's the breakdown of all three runners, and a clear pick for each situation.

Which test runner is fastest?

Bun Test wins raw execution, Vitest wins the feedback loop, and Jest comes last. On a small suite, Bun's runner can finish in around 0.08 seconds where Jest takes about 1.2 and Vitest about 0.9. But raw start time isn't the number you feel all day. In watch mode, Vitest reruns only the tests affected by a change in tens of milliseconds, while Jest takes seconds. On a large monorepo, published benchmarks put Vitest at roughly 5x faster cold and up to 28x faster on watch reruns than Jest 30, with lower memory. The catch: below about 30 tests, all three feel instant and the difference is academic.

Quick verdict

Tool	Best for	Speed	Rating
Vitest	New Vite or TypeScript projects, best all-round	Very fast, instant watch mode	4.8/5
Jest	React Native, large legacy and enterprise suites	Slowest, most mature	4.3/5
Bun Test	Bun-native projects, pure logic unit tests	Fastest raw execution	4.0/5

Vitest: the default for new projects

Vitest, built by Anthony Fu and the Vite team, is the runner most new projects should reach for in 2026. It's on version 4.x, and its whole design is about reusing what Vite already does. If your app has a vite.config.ts, Vitest picks up your aliases, plugins, and resolve conditions automatically, so test configuration is close to zero. TypeScript and JSX compile through esbuild as part of the normal pipeline, with no ts-jest or Babel layer to maintain.

The two things you feel immediately are ESM and watch mode. Vitest treats ES Modules as the default because Vite does, so import.meta, top-level await, and ESM-only packages just work without flags. Its watch mode tracks the module graph the same way Vite's dev server does, so changing one file reruns only the tests that import it, usually in under a second. It also ships coverage (V8 or Istanbul, with HTML reports and CI thresholds), a UI mode, and a stable browser mode that runs tests in real Chromium via Playwright.

The API is intentionally a near-clone of Jest. describe, it, expect, and the lifecycle hooks are identical; you set globals: true and swap jest. for vi..

Who should not use Vitest: React Native teams, since it has no first-class support there. And if you're sitting on a huge Jest suite with custom serializers and deep module mocks, budget for the migration rather than assuming it's free. Vitest's snapshot format differs from Jest's, so you'll regenerate snapshots, and its ecosystem, while strong, is still younger than Jest's decade of plugins.

Jest: still the safe, battle-tested choice

Jest turned eleven in 2025 and shipped Jest 30 that June. It's the most historically referenced test runner in JavaScript, still pulling tens of millions of weekly downloads, and its ecosystem is unmatched: jest-dom, jest-axe, image-snapshot, mature custom serializers, and the deepest pile of Stack Overflow answers and AI training data for debugging obscure issues.

Jest 30 closed real ground. It's meaningfully faster than Jest 29, uses far less peak memory, added native .mts and .cts support, TypeScript config files, and the using keyword for automatic spy cleanup. If you bounced off Jest's ESM story in 2023, it's stabler now.

Where Jest still leads outright is React Native, where it's the only officially supported runner, and large CommonJS monorepos where its behavior is known and its sharding is battle-hardened for suites in the tens of thousands of tests. NestJS and much of the Angular world default to it.

Who should not use Jest: anyone starting a fresh Vite or ESM-first project. Native ESM still often needs the --experimental-vm-modules flag, and mocking an ESM module means jest.unstable_mockModule instead of the clean synchronous call. Cold starts and watch mode are the slowest of the three, especially with ts-jest, and you carry more configuration than Vitest needs. Nothing about Jest is broken, but for a modern greenfield app it's the harder path.

Bun Test: the fastest, if you live in Bun

Bun's built-in test runner, imported from bun:test, is the speed demon. It ships inside the Bun runtime, so there's nothing to install if you already use Bun, and it leans on Bun's native TypeScript transpiler and JavaScriptCore engine to run tests dramatically faster than either rival on pure logic. Its API is Jest-compatible, and it even uses Jest-compatible snapshot serialization, so moving simple Jest tests over is often close to zero code changes.

For a Bun-native project, that's a clean story: one toolchain for your runtime, package manager, and tests, with the fastest feedback loop of the three.

Who should not use Bun Test: most teams with a complex or Node-hosted suite. The gaps are real in 2026. Coverage is experimental, with no HTML reports and branch coverage needing workarounds. Its module mocking is weaker than vi.mock, and complex module mocking often fails. Watch mode reruns every test on any change, with no Vite-style dependency graph. And it only runs in Bun, so your CI has to install Bun, and you're testing in a different runtime than a Node production server, which can surface subtle differences. In real tests it also broke on MSW (no Service Worker API), Prisma mocking, and monorepo workspace imports. It's excellent for utility libraries and backend logic, and risky for DOM-heavy or mocking-heavy suites.

How much configuration does each need?

This is where the daily experience really diverges. On a Vite project, Vitest needs almost nothing:

// vitest.config.ts
import { defineConfig } from 'vitest/config'

export default defineConfig({
  test: {
    globals: true,
    environment: 'jsdom',
    coverage: { provider: 'v8' },
  },
})

Jest, on a TypeScript project, wants more moving parts: a transform, an environment, and usually a module name mapping for path aliases.

// jest.config.js
module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'jsdom',
  moduleNameMapper: {
    '^@/(.*)$': '<rootDir>/src/$1',
  },
}

Bun Test needs no config file at all. You write a test that imports from bun:test and run bun test.

import { describe, it, expect } from 'bun:test'

describe('add', () => {
  it('sums two numbers', () => {
    expect(add(1, 2)).toBe(3)
  })
})

The pattern holds across all three: Bun and Vitest lean on native TypeScript and sensible defaults, while Jest asks you to wire up the transform layer yourself.

What about mocking and coverage?

Two features quietly decide a lot of migrations.

Mocking is where Bun Test still trails. Vitest's vi.mock and Jest's jest.mock are mature and handle module-level mocking, partial mocks, and spies without drama. Bun's mock from bun:test covers the basics but falls over on complex module mocking, which is exactly the kind of thing a real app accumulates over time. If your suite mocks a lot of modules, that alone can rule Bun out.

Coverage tells a similar story. Vitest ships V8 and Istanbul providers with HTML reports and CI thresholds, and Jest's coverage is equally mature. Bun's coverage is still experimental in 2026: fine for a quick percentage, but short on HTML output and branch coverage without workarounds. For a solo founder who just wants a coverage number gating CI, Vitest and Jest are the safer bet.

Head-to-head on what matters

Speed. Bun wins raw execution, sometimes by a wide margin on many small unit tests. Vitest wins the metric you actually live with: watch-mode reruns, thanks to its HMR-style module graph. Jest is the slowest, though switching its transformer to SWC narrows the cold-start gap.

ESM and TypeScript. Vitest and Bun handle both natively with no extra plumbing. Jest 30 improved here but native ESM still leans on a flag, and TypeScript goes through ts-jest, Babel, or SWC. For an ESM-first codebase, this single difference often settles the choice.

Ecosystem. Jest is deepest by a distance. Vitest is close enough that Testing Library, MSW, and the common tools all work well. Bun's plugin ecosystem is the thinnest, and Jest or Vitest plugins don't automatically run under it.

Migration. Jest to Vitest is mostly mechanical: config tweak, jest. to vi., then regenerate snapshots because the format is denser. A small suite is about a day. Jest to Bun preserves snapshots but the mocking gaps bite on anything non-trivial.

View the interactive diagram on devtoolpicks.com

Migrating from Jest to Vitest without drama

If you decide to move, the path is well worn. A rough order that works:

Install vitest, plus jsdom or happy-dom for component tests.
Add a vitest.config.ts (or extend your existing vite.config.ts) and set globals: true so you don't have to rewrite every import.
Run a codemod or find-and-replace to swap jest. calls for vi..
Regenerate snapshots with the --update flag, then review every diff, because Vitest's format is denser than Jest's.
Fix the stragglers: complex module mocks, fake timers, and any custom transforms.

For a suite under a few thousand tests, this is roughly a day of work. Large monorepos are best done one package at a time, running both runners side by side until each package is green.

The verdict

For most indie hackers starting something new in 2026, Vitest is the pick. It's fast where it counts, it needs almost no config on a modern stack, ESM and TypeScript just work, and because its API mirrors Jest you're not learning a new mental model. The watch-mode speed alone changes the rhythm of how you work.

Stay on Jest when the situation calls for it, and be honest about when it does: React Native, a big stable suite that already works, or deep Jest-specific tooling you don't want to rebuild. Jest 30 is a good tool, not a legacy one, and migrating purely to chase benchmarks is usually a waste of a weekend.

Bun Test is the one to watch. If you've already adopted Bun as your runtime and your tests are mostly pure logic, it's the fastest feedback loop you can get, and using it is consistent with that choice. Just go in knowing the coverage, mocking, and ecosystem gaps, and keep it away from your DOM-heavy and mocking-heavy suites for now.

Once your unit tests are sorted, the next layer is end-to-end. Our Playwright vs Cypress vs Selenium comparison covers that side, and if you're weighing the runtime underneath it all, Bun vs Node vs Deno and pnpm vs npm vs Yarn vs Bun are the natural next reads. For testing your API layer, see our best API testing tools roundup.

Best Twilio Alternatives for Indie Hackers in 2026 (Cheaper SMS APIs)

DevToolsPicks — Thu, 16 Jul 2026 04:30:18 +0000

Originally published at devtoolpicks.com

Twilio's SMS pricing looks reasonable until you read the invoice.

The advertised US rate is $0.0079 per message segment. Then the carrier surcharges land. AT&T, T-Mobile, and Verizon each add roughly $0.003 to $0.005 per segment on top, which pushes the real cost to around $0.011 to $0.013. And before you send a single message, US application-to-person SMS requires A2P 10DLC registration: a brand fee, a per-campaign vetting fee, and a monthly charge per campaign. For a solo founder sending OTP codes or order updates, the base rate was never the whole story.

Here's the short version. Telnyx is the cheapest carrier-grade option at $0.004 a segment. Plivo is the closest thing to a drop-in Twilio replacement. Vonage has the best built-in Verify API if OTP is your use case. Amazon SNS is the pick if you already live in AWS. And Bird is the one to look at for SMS plus WhatsApp in one place.

Five alternatives below, with real US pricing and who each one is wrong for.

Does switching from Twilio avoid A2P 10DLC fees?

No, and this trips people up constantly. A2P 10DLC registration and the carrier surcharges that come with it are set by the US carriers, not by Twilio. Every provider here enforces the same brand and campaign registration through The Campaign Registry, and the same per-message carrier fees apply on top of whatever the provider charges. Switching away from Twilio lowers your per-segment base rate. It does not get you out of the paperwork or the carrier fees. Keep that in mind when you compare the numbers below, because those numbers are base rates.

What actually drives your SMS bill?

Four things move your invoice, and only one of them is the headline per-segment rate.

Message segments come first. Carriers count a segment as 160 characters of plain GSM-7 text. Go over that, or drop in an emoji or a non-Latin character, and the message shrinks to 70 characters per segment and splits into more billable parts. A chatty OTP message with a branded footer can quietly cost double what you budgeted.

Then there's number rental, a flat monthly fee per phone number, usually $0.80 to $1.15. Verification is its own line if you use a managed OTP product like Twilio Verify or Vonage Verify. And the carrier surcharges and monthly A2P 10DLC campaign fees sit on top of all of it, roughly the same across every provider.

The practical takeaway: keep transactional messages short and inside a single GSM-7 segment, rent the minimum numbers you need, and compare providers on the all-in number rather than the advertised base rate.

Quick verdict

Tool	Best for	US SMS (per segment)	Rating
Telnyx	Cheapest carrier-grade SMS and voice	$0.004 outbound	4.6/5
Plivo	Near drop-in Twilio replacement	$0.0077 outbound	4.5/5
Vonage	OTP and 2FA with a Verify API	$0.0081 outbound	4.1/5
Amazon SNS	AWS-native transactional SMS	~$0.005 plus carrier fee	4.0/5
Bird (MessageBird)	SMS plus WhatsApp and email in one	Quote-based	3.8/5
Twilio	Broadest CPaaS ecosystem	$0.0079 outbound, plus fees	4.0/5

Telnyx: the cheapest carrier-grade option

Telnyx is the cheapest credible option here, and it's cheap because it owns its network. Instead of renting routes from carriers like most CPaaS providers, Telnyx runs its own private IP backbone and connects to carriers directly. That's how it prices US outbound SMS at $0.004 a segment, roughly half Twilio's base rate, with inbound at the same $0.004 and local numbers from $1 a month.

The developer experience matches the price. The Mission Control dashboard is clean, the docs are detailed, and every account gets free 24/7 support from in-house engineers rather than a ticket queue. It covers SMS, MMS, voice, SIP trunking, number lookup, and a Verify API for OTP. For a technical solo founder, this is Telnyx at its best: cheap, fast, and flexible, with pay-as-you-go billing.

Who should not use Telnyx: non-technical builders. The platform assumes you're comfortable with telecom concepts like SIP trunking and inbound trunk groups, and there are no pre-built no-code flows, so no Zapier or GoHighLevel recipes out of the box. There's also no free plan; you fund a pay-as-you-go balance. And the carrier surcharges still stack on top of that $0.004, the same as everywhere else.

Plivo: the near drop-in Twilio replacement

Plivo is the one to pick if you already run Twilio and just want the bill to shrink. Its API was designed to mirror Twilio's, PlivoML maps closely to TwiML, and the SDKs cover the same languages, so migrating is usually a matter of hours or days rather than a rewrite. US outbound SMS is $0.0077 a segment, inbound is $0.0055, and numbers start at $0.80 a month, all with a 99.99% uptime SLA and no monthly minimum.

You get SMS and voice together with a clean API and transparent US pricing. For most teams already comfortable with Twilio's patterns, Plivo is the lowest-friction way to cut costs without retraining anyone.

Who should not use Plivo: teams leaning on Twilio's wider ecosystem. If you use Twilio Studio (the visual flow builder) or Twilio Functions (serverless), Plivo has no direct equivalent, so you'd rebuild those flows. Its integration library and non-messaging product range are smaller than Twilio's, and support depth varies by plan. The per-segment saving over Twilio is real but modest at list price, so the bigger wins show up at higher volume.

Vonage: the pick for OTP and verification

Vonage, formerly Nexmo, isn't the cheapest here. US outbound SMS runs about $0.0081 a segment, roughly the same as Twilio. You pick Vonage for two other reasons: its Verify API and its global reach. The Verify API handles OTP and 2FA across SMS, voice, and WhatsApp, and you only pay for successful verifications, which takes the retry and fraud logic off your plate. Coverage spans 190-plus countries with adaptive routing that fails over between carriers to protect deliverability.

It's a mature platform, now owned by Ericsson, with a large developer base and a straightforward pay-as-you-go model.

Who should not use Vonage: anyone chasing the lowest US SMS price. On raw US segments it doesn't beat Twilio, let alone Telnyx or Plivo, so if cost is your only driver, look elsewhere. The documentation also trails the market leaders for complex scenarios. Vonage earns its place when OTP verification or wide international coverage matters more than shaving a fraction of a cent off each domestic message.

Amazon SNS: the AWS-native option

If your stack already lives in AWS, Amazon SNS, now billed under AWS End User Messaging, is the least-friction option because there's no new vendor to onboard. You send SMS through the same SDK and IAM permissions you already use, and it's cheap: the AWS message fee is $0.005 per outbound message, and with the US carrier fee it lands somewhere around $0.006 to $0.008 a segment. Response times are fast and it scales without you thinking about it.

The catch is that it's infrastructure, not a product. There's no messaging dashboard, no visual flows, and no hand-holding.

Who should not use Amazon SNS: anyone who wants a polished messaging platform, or anyone not already on AWS. New accounts start in an SMS sandbox and need a support request to reach production, the default spend cap is $1 until you raise it, and there's no SMS free tier, so every message is billed from the first one. It's a great transactional-SMS pipe for AWS-native teams and a poor fit for everyone else.

Bird (MessageBird): the omnichannel pick

Bird, the platform formerly known as MessageBird, is the omnichannel choice. Instead of just SMS, it bundles WhatsApp, email, and Messenger into one product with a visual Flow Builder that lets non-technical teammates design messaging workflows without code. If you want to send a login code over SMS, a receipt over WhatsApp, and a newsletter over email from a single vendor, this is the shape that fits.

It's an established European platform with more than 15,000 customers and SOC 2 and ISO 27001 certifications.

Who should not use Bird: developers who want transparent, predictable API pricing. Since the rebrand from MessageBird, published SMS rates have become harder to pin down and are largely quote-based, so confirm current US pricing with Bird before you commit. The product has also broadened toward marketing and CRM rather than a pure developer API, and the roadmap has shifted more than once. If you only need a clean SMS API, one of the developer-first options above will serve you better.

How do you choose the right one?

Start from the reason you went looking.

You want the lowest US SMS price: Telnyx at $0.004 a segment, if you're comfortable with telecom-grade tooling.
You're already on Twilio and want to cut the bill fast: Plivo. Near drop-in API, migration in hours.
Your main use is OTP or 2FA: Vonage's Verify API, or check whether your auth provider already does it.
You live in AWS: Amazon SNS. Cheap and native, no extra vendor.
You need SMS plus WhatsApp and email: Bird.

One more honest option: you might not need an SMS provider at all. If SMS is purely for login codes, email OTP costs a fraction of a cent and skips 10DLC entirely, and several auth platforms ship verification out of the box. Weigh that before you wire up any of these.

View the interactive diagram on devtoolpicks.com

A note on what's not here: Sinch and Bandwidth are strong SMS providers, but they're built for enterprise volume. Bandwidth matches Telnyx at $0.004 a segment yet onboards through sales and really wants a million-plus messages a month, and Sinch sits around $0.0065 as a global enterprise default. Neither is a natural fit for a solo founder, which is why they're not in the main list.

The verdict

For most indie hackers, Telnyx is the smartest default. It's the cheapest carrier-grade option, the developer experience is strong, and free 24/7 engineer support is rare at this price. If you're already running Twilio and don't want to touch your integration much, Plivo gets you most of the savings for a fraction of the effort. Choose Vonage when OTP verification is the whole point, and Amazon SNS when you're deep in AWS already.

Twilio is still the most complete platform, and if you need its full range of channels and integrations, it earns the premium. But for a solo founder sending order alerts and login codes, you're paying enterprise prices for a text message. The cheaper options here do the same job, and the only thing you can't escape is the 10DLC paperwork, which follows you no matter who you pick.

If you're mapping out the rest of your messaging stack, our Resend vs Postmark vs Mailgun comparison covers the email side, and if SMS was only ever for login codes, Clerk vs Auth0 vs Supabase Auth shows which auth tools handle verification for you. For the rest of your backend, see our Supabase alternatives and Sentry alternatives guides.

Best Feature Flag Tools for Indie Hackers in 2026 (Free and Cheap Picks)

DevToolsPicks — Tue, 14 Jul 2026 04:15:13 +0000

Originally published at devtoolpicks.com

LaunchDarkly is the name everyone reaches for when they hear "feature flags." It's also the reason a lot of indie hackers go looking for something else.

The free Developer plan sounds generous until you read the caps: 1,000 client-side monthly active users and 5 service connections. Cross either line and you land on the Foundation tier, which is usage-based at roughly $10 to $12 per service connection per month plus about $8 to $10 per 1,000 client-side MAU, with experimentation and observability billed on top. The median LaunchDarkly buyer pays around $72,000 a year. That's a reasonable number for a funded team with a platform org. It's absurd for a solo founder who wants to hide a half-finished checkout behind a toggle.

Here's the good news. You almost certainly don't need to pay. If you build in Laravel, Pennant gives you flags for free in your own database. If you want flags bundled with analytics, PostHog's free tier covers a million flag requests a month. And three open-source platforms run on your own infrastructure for nothing.

Six tools below, with real pricing and who each one is wrong for.

Do you even need a feature flag service?

Be honest about what you're solving. For a single on/off toggle, an environment variable or a config value does the job. You start needing a real tool once you want percentage rollouts, per-user targeting, an audit trail, and the ability to flip something in production without a redeploy. That's the line. Below it, keep it simple. Above it, pick one of these rather than building your own, because every option here is free or cheap enough that rolling your own stops making sense.

Quick verdict

Tool	Best for	Price	Rating
Laravel Pennant	Laravel apps that want flags with no SaaS	Free, first-party package	4.6/5
PostHog	Flags bundled with product analytics	Free up to 1M flag requests/mo	4.7/5
Flagsmith	Open source with remote config	Free self-host. Cloud free to 50K req, then $45/mo	4.4/5
Unleash	Privacy-focused, self-hosted at scale	Free self-host. Cloud $75/seat/mo	4.3/5
GrowthBook	Flags plus built-in A/B testing	Free self-host. Cloud free for 3 users, Pro $40/seat/mo	4.4/5
ConfigCat	Simplest managed, unlimited seats	Free (10 flags). Pro $110/mo	4.3/5
LaunchDarkly	Enterprise governance and scale	Free (1K MAU cap), then usage-based	3.8/5

Laravel Pennant: flags with no extra service

If you build in Laravel, start here. Laravel Pennant is the framework's first-party feature flag package, and it's free. You install it with composer require laravel/pennant, run one migration, and you have a features table in your own database doing the work. No external service, no per-request meter, no dashboard subscription.

The API is clean. You define a flag in a service provider, check it with Feature::active('new-dashboard'), and gate Blade views with @feature. Percentage rollouts are one line with Lottery::odds(1, 10) for a 10% release, and once a user is bucketed, Pennant stores the result so they don't flicker between states. It also supports rich non-boolean values, class-based feature definitions, and route middleware.

Pricing is nothing beyond the database you already run. That's the whole point.

Who should not use Pennant: teams that need a hosted UI where non-technical people flip flags themselves. Pennant is code-first, so a product manager can't toggle a feature without you building an admin screen (Filament makes this easy, but it's still work). It's scoped to one Laravel app, and it has no built-in experimentation statistics. If you need A/B analysis or cross-service flags, look further down this list.

PostHog: flags plus analytics on one free tier

PostHog is the pick if you already want product analytics, because feature flags come bundled and the free tier is huge. You get 1 million flag requests a month free, alongside 1 million analytics events, 5,000 session recordings, and more. More than 90% of companies never pay. There's no per-seat charge either, so your whole team can log in without the bill moving.

The flags themselves are solid: percentage rollouts, user targeting, local evaluation to cut latency, and experiments with real statistical analysis sitting right next to the flag. Because it's one platform, you can ship a flag, watch the analytics, and check a session replay of the new flow without wiring three tools together. Past the free tier, flag requests cost $0.0001 each and step down sharply at volume.

PostHog is open source and self-hostable too, though that path is heavy.

Who should not use PostHog: anyone who wants only feature flags and nothing else. The platform is a suite, and its bill is built from many separate meters (events, replays, surveys, flags), so it's easy to overspend once you turn everything on. Self-hosting is not lightweight either, it needs ClickHouse, Kafka, Postgres, and Redis. If your search is strictly "cheapest flag toggle," this is more machine than you need.

Flagsmith: open source with remote config

Flagsmith is the open-source option built specifically around feature flags and remote configuration. It's BSD licensed, so you can self-host it on your own infrastructure with unlimited flags, environments, and users at zero cost. That's the strongest reason to pick it: full control and no vendor lock-in.

Beyond simple toggles, Flagsmith does remote config well. You can change app settings, copy, or limits without shipping a new build, and a single flag can carry a JSON value that controls several related settings at once. Identity management lets you target users by traits like plan, country, or signup date, and every change is logged in an audit trail.

On the managed side, the cloud free tier gives you 50,000 requests a month on a single seat, and paid plans start at $45/month. Self-hosting stays free with no request limits.

Who should not use Flagsmith: teams that want advanced governance without paying. On the self-hosted open-source build, SSO, role-based access control, and full audit logs are gated to the Enterprise tier. Its A/B testing is basic and leans on an analytics integration for real statistical work, so if experimentation is your main goal, GrowthBook or PostHog fit better. And self-hosting means you're running PostgreSQL and handling maintenance yourself.

Unleash: the established self-hosted platform

Unleash is the most mature open-source flag platform, with over 10,000 GitHub stars and 20 million-plus downloads. It's popular with privacy-conscious teams because user data never has to leave your infrastructure. You define targeting rules, gradual rollouts, and custom activation strategies, and the SDK coverage is the widest of any tool here.

Self-hosting the open-source version is free and works well for a single project. The managed cloud runs $75 per seat per month, which includes a generous 53 million API requests and adds SSO, RBAC, SOC 2, and change-approval workflows. Enterprise pricing is custom, with self-hosted Enterprise starting at a 5-seat minimum.

Who should not use Unleash: small teams watching per-seat cost. At $75 a seat, the managed cloud adds up faster than usage-based or flat-rate rivals once you have a few people. The free open-source edition is also limited to a single environment and a single project, so multi-environment setups push you toward paid or a more involved self-hosted deployment. It requires a relational database backend, and like Flagsmith, it has no built-in experimentation statistics.

GrowthBook: flags with real A/B testing built in

GrowthBook is the open-source choice when experimentation matters as much as the flag. It's MIT licensed and free to self-host with unlimited users, flags, and experiments. The cloud Starter plan is free for up to three users, also with unlimited flags and experiments, which is unusually generous.

What sets it apart is the stats. GrowthBook is warehouse-native, so it can run experiment analysis directly on your data in Snowflake, BigQuery, or Redshift without exporting events to a third party. It offers both Bayesian and frequentist engines, and the JavaScript SDK is only 9KB with local evaluation. The Pro tier at $40 per seat per month unlocks the heavier statistical methods like CUPED variance reduction and sequential testing.

Who should not use GrowthBook: solo devs who just want a kill switch. If you never plan to run a real experiment, its warehouse-native, stats-heavy design is more than you need, and simpler tools will get you shipping faster. The advanced statistics that justify GrowthBook sit behind the Pro plan, so the free tier is more of a flag tool than a full experimentation platform until you upgrade.

ConfigCat: the simplest managed option

ConfigCat wins on simplicity and predictable pricing. Its free forever plan gives you 10 flags across 2 products and 2 environments, and here's the part that matters: unlimited team members and SSO/SAML on every plan, including free. It doesn't charge per seat or per monthly active user, so the bill never surprises you.

Setup is fast, the SDK coverage is broad, and the dashboard is clean enough that non-technical teammates can manage flags without help. Paid plans are flat: Pro is $110/month for 100 flags and higher limits, Smart is $325/month for unlimited flags, and larger tiers exist above that. Everyone gets the same features, only the limits change.

Who should not use ConfigCat: teams that will blow past 10 flags quickly and don't want the jump to $110/month. The free tier is genuinely useful but its flag cap is low, so a busy app outgrows it faster than PostHog's request-based free tier. And if deep experimentation statistics are your reason for buying, ConfigCat supports experimentation workflows through analytics integrations but isn't trying to be a full A/B testing suite.

How do you choose the right one?

Match the tool to your stack and your actual need.

You build in Laravel: Laravel Pennant. Free, first-party, in your own database. Nothing to host.
You want flags plus analytics for free: PostHog. A million flag requests a month, no per-seat cost.
You want open source with remote config: Flagsmith. Self-host free, or a cheap cloud entry.
You care about data residency and self-hosting: Unleash. The most established option, privacy-first.
You want to A/B test, not just toggle: GrowthBook. Flags and real experimentation in one place.
You want the simplest managed dashboard: ConfigCat. Unlimited seats and SSO even on the free plan.

View the interactive diagram on devtoolpicks.com

The verdict

For Laravel builders, Laravel Pennant is the obvious default. It's free, it lives in your own database, and it does everything a solo founder needs for safe rollouts. If you're not on Laravel, PostHog is the best all-round free pick because the flag tier is huge and you get analytics in the same tool. Want to genuinely experiment rather than just toggle? GrowthBook. Want the least fuss and a dashboard your teammates can use? ConfigCat.

LaunchDarkly is a genuinely strong platform, and if you're a funded team that needs enterprise governance, SSO/SCIM, and release automation, it earns its price. But that's not most people reading this. The honest takeaway is that feature flags are close to a solved problem at the indie scale, and you can have them for free.

Feature flags pair naturally with the rest of your release safety net. If you're setting up error tracking alongside them, our Sentry alternatives guide covers the cheap options, and for deployment our take on Laravel Forge vs Ploi vs Coolify fits the same trunk-based workflow. If you go the PostHog route, our PostHog vs Plausible vs Fathom vs Mixpanel and Hotjar vs Microsoft Clarity vs PostHog comparisons go deeper on the analytics side.

Best Algolia Alternatives for Indie Hackers in 2026 (Honest Picks)

DevToolsPicks — Mon, 13 Jul 2026 04:20:10 +0000

Originally published at devtoolpicks.com

Algolia's free Build plan is generous. The bill after you launch is the problem.

The moment you move to the Grow plan, you pay $0.50 per 1,000 searches and $0.40 per 1,000 records beyond the included tier. Turn on the AI search features that made Algolia famous and Grow Plus charges $1.75 per 1,000 searches. For a search box that fires a request on every keystroke, that adds up quietly. A mid-traffic store handling half a million searches a month can land around $245 in overages before AI, and the same volume on Grow Plus pushes toward $850. That is the story behind most "why is my Algolia bill so high" threads.

Here's the short version. If you build in Laravel, Meilisearch is the easiest switch because it's a first-party Scout driver. If you're scaling to real query volume, Typesense bills for resources instead of per search, so your cost stops tracking your traffic. If your search lives in a docs site or a JS-heavy frontend, Orama runs at the edge for free. And if your catalog is small, you might not need a search service at all. Postgres can handle it.

Five real alternatives below, with verified pricing and an honest note on who should skip each one.

Why does the Algolia bill creep up?

Algolia prices on two axes at once: search requests and records stored. Both scale with your success. More traffic means more requests, a bigger catalog means more records, and the AI features sit behind the pricier Grow Plus tier. None of it is hidden, but it's hard to forecast, and the number that looks tiny in development gets real once you launch. The free Build plan also deletes inactive apps after 60 days, which stings if you set something up early and launch late.

Quick verdict

Tool	Best for	Price	Rating
Meilisearch	Easiest Algolia swap, Laravel-native	Free self-host. Cloud from $30/mo	4.7/5
Typesense	High query volume without per-search fees	Free self-host. Cloud from ~$7/mo (resource-based)	4.6/5
Orama	Docs sites and JS or edge search	Free open source. Cloud pricing on request	4.2/5
Postgres full-text search	Small catalogs, use your existing database	Free, built in	4.3/5
OpenSearch / Elasticsearch	Search plus log analytics at scale	Free self-host. Managed from ~$95/mo	3.6/5

Meilisearch: the easiest switch for Laravel builders

Meilisearch is an open-source, Rust-powered search engine that feels like Algolia without the meter running. You get typo tolerance, faceted filtering, and sub-50ms responses out of the box. It's MIT licensed, so self-hosting is genuinely free, and it runs as a single binary or Docker container with almost no config.

For a Laravel app this is the smoothest path of anything here. Meilisearch is a first-party Laravel Scout driver, so you add the Searchable trait to a model, set SCOUT_DRIVER=meilisearch, and Scout keeps your index in sync automatically. Laravel Sail even ships a Meilisearch service by default, so local search works in one command.

Pricing is the clear win. Self-host for free on a $5 to $10 VPS for small to medium workloads. If you'd rather not run it, Meilisearch Cloud starts at $30/month on the usage-based Build plan (50,000 searches and 100,000 documents, then overages) or $23/month on the resource-based plan where you pay for dedicated CPU and RAM instead of per query. The Pro tier is $300/month. There's a 14-day trial with no credit card.

Who should not use Meilisearch: teams that need Algolia's mature A/B testing and built-in personalization engine, since those aren't there yet. The managed Cloud has also had documented reliability wobbles, so for critical production many teams self-host instead. And vector search, while supported, is less battle-tested than the keyword side.

Typesense: predictable cost at high query volume

Typesense is the other open-source heavyweight, and its pricing model is the reason people switch from Algolia at scale. Typesense Cloud charges for the resources you provision, a fixed hourly cluster fee based on RAM, CPU, and options like high availability. There's no per-record or per-search charge. Your search box can fire a million queries and the bill doesn't move.

That matters for any indie hacker whose traffic is spiky or growing. One founder in Typesense's own testimonials moved off a $5,000/month Algolia bill and paid a fraction of it after migrating in about an hour. The engine itself is fast, typo-tolerant, and supports keyword, semantic, geo, and vector search.

It's also a first-party Laravel Scout driver. You install the Typesense PHP SDK, set your host and API key, and define your collection schema in config/scout.php. The one Laravel gotcha: your toSearchableArray has to cast the primary key to a string and the created date to a UNIX timestamp.

On price, self-hosting is free (open source). Typesense Cloud is resource-based and starts around $7/month for the smallest cluster, though a small production setup is more realistically $20 to $50/month depending on RAM. New accounts get 720 free cluster-hours to test.

Who should not use Typesense: anyone who wants zero infrastructure decisions. The cloud setup asks you to pick RAM and CPU upfront, which is more thinking than Meilisearch's fixed tiers. Bandwidth is billed per GB on top of the cluster fee, so very high result volumes add cost.

Orama: free search that runs at the edge

Orama takes a different shape. It's an open-source full-text, vector, and hybrid search engine written for JavaScript that runs anywhere JS runs: the browser, the server, or an edge network like Cloudflare Workers. The core library is tiny, under 2KB, and it already powers search on nodejs.org and the TanStack docs.

For an indie hacker this is the pick when search lives in the frontend. A documentation site, a client-side product filter, or a static site where you don't want to run a search server at all. You index your data, ship the search into the bundle or an edge function, and there's no round trip to a paid API on every keystroke. Hybrid search means you can mix keyword and semantic results in one query.

Pricing on the open-source library is simply free. Orama Cloud exists as a hosted option built on OramaCore, but its public pricing isn't clearly listed right now, so treat the managed tier as quote-based and verify before you commit.

Who should not use Orama: anyone who needs a traditional server-side search index for a large database-backed catalog. It's not a Laravel Scout driver, so a Laravel-heavy backend gets less benefit than it would from Meilisearch or Typesense. And running full AI answer features through OramaCore leans on a GPU, which is overkill for basic search.

Postgres full-text search: you might not need a search service

Before you pay anyone, check whether your database already does the job. Postgres full-text search is built in, free, and good enough for a lot of apps. It handles ranked keyword search with tsvector and tsquery, and a GIN index keeps it fast. Add the pg_search extension from ParadeDB and you get BM25 relevance that lands much closer to a dedicated engine.

The Laravel angle is real here too. Scout ships a database driver that uses your MySQL or Postgres full-text indexes directly, so you can add search with zero new services and swap to Meilisearch later by changing one env variable. For a small catalog, an internal tool, or an early MVP, this is the honest answer: don't add a search vendor you'll have to rip out.

Cost is nothing beyond the database you already run.

Who should not use Postgres search: anyone who needs instant search-as-you-type with forgiving typo tolerance across a large dataset. Postgres won't feel as sharp as Meilisearch or Typesense for that, and heavy search traffic competes with your app's normal queries for the same database resources. Once search becomes a core feature rather than a nice-to-have, move it off Postgres.

OpenSearch and Elasticsearch: powerful, but usually overkill

OpenSearch and Elasticsearch are the heavyweight option, and for most indie hackers leaving Algolia they're the wrong direction. These engines are built for search plus log analytics, aggregations, and observability at scale. If you only need a fast product search box, you'll be running a cluster you don't need.

The cost picture makes the point. OpenSearch is Apache 2.0 licensed and free to self-host, but a small managed 3-node cluster on Amazon OpenSearch Service runs roughly $1,600/month. Elasticsearch's core is free to self-host too, and Elastic Cloud Hosted starts around $95/month for the Standard tier, but a real production deployment more commonly lands between $1,500 and $8,000/month. Self-hosting either one means you own cluster sizing, upgrades, and tuning.

Who should actually use it: teams that genuinely need search and log analytics in one place, or complex aggregations that pure search engines can't do. If that's you, the power is worth it. If you just want your users to find products fast, pick Meilisearch or Typesense and move on.

How do you choose the right one?

Match the tool to your situation, not to a feature list.

You build in Laravel and want the fastest switch: Meilisearch. First-party Scout driver, free to self-host, done in an afternoon.
Your traffic is high or spiky and per-search pricing scares you: Typesense. Resource-based billing means cost tracks your server, not your search volume.
Search lives in a docs site or JS frontend: Orama. Free, runs at the edge, no server to babysit.
Small catalog or early MVP: Postgres full-text search through the Scout database driver. Add a real engine later.
You also need log analytics at scale: OpenSearch or Elasticsearch. Otherwise it's too much machine.

View the interactive diagram on devtoolpicks.com

The verdict

For most indie hackers, Meilisearch is the default. It matches the parts of Algolia you actually use, it's free to self-host, and it drops straight into Laravel Scout. If your traffic is heavy enough that per-search pricing keeps you up at night, Typesense is the smarter long-term bet because resource-based billing decouples cost from volume. Orama wins for docs and edge search, and Postgres quietly wins for small catalogs where a search vendor is premature.

The common thread: Algolia's per-search model punishes growth, and every option here breaks that link, either by self-hosting for free or by charging for resources instead of requests. Start with the one that fits your stack today, not the one with the longest feature page.

If you're rethinking your backend stack while you're at it, our take on Supabase alternatives and Turso vs Neon vs Supabase covers the database side. For AI apps that need vector search specifically, see Pinecone vs Weaviate vs Qdrant. And if you're auditing your whole tooling bill, Sentry alternatives is a good next stop.

pnpm vs npm vs Yarn vs Bun for Indie Hackers in 2026: Which Package Manager Wins?

DevToolsPicks — Fri, 10 Jul 2026 04:45:09 +0000

Originally published at devtoolpicks.com

Every JavaScript project you'll ever ship starts with the same invisible decision, and most of us made it by typing npm install out of habit. In 2026 that habit has a measurable cost. The gap between the four package managers has never been wider: one of them installs dependencies 17x faster than npm, another cuts your disk usage by two thirds, and one just got acquired by an AI company betting a billion-dollar product on it.

My verdict upfront: pnpm should be your default in 2026. It's the best balance of speed, disk efficiency, correctness, and compatibility, and it asks nothing of you except two commands to migrate. Bun is faster still, but choosing it is a runtime decision disguised as a package manager decision. npm is fine and always will be. And Yarn, despite being technically excellent, is the one I'd no longer start a project on.

Here's the reasoning, with numbers.

Quick Verdict

Tool	Best For	Price	Rating
pnpm	Most projects, monorepos, multiple projects per machine	Free (OSS)	9.3/10
Bun	Greenfield projects already on the Bun runtime	Free (OSS, MIT)	8.7/10
npm	Zero-setup defaults, maximum compatibility	Free (ships with Node)	7.8/10
Yarn	Teams already invested in Plug and Play	Free (OSS)	7.2/10

What Actually Changed in 2026?

All four shipped meaningful releases, which is why older comparisons mislead.

npm 11 focused on supply-chain security: a min-release-age setting that refuses to install packages published in the last N days (catching hijacked releases before you do), plus npm trust for provenance. pnpm 10 went further and made lifecycle scripts opt-in by default, so a compromised package can no longer run arbitrary code on install unless you allow it. That's the strictest default of the four, and after the supply-chain incidents of the last two years, it matters.

Yarn 4 matured Plug and Play and rewrote its constraints engine in JavaScript. And Bun 1.3 added dependency catalogs, bun why, and interactive updates, on top of the biggest news in the category: Anthropic acquired Bun on December 2, 2025. Bun stays MIT-licensed and open source, the same team keeps building it, and Claude Code now ships as a Bun executable to millions of users. Whatever you think of the acquisition, it answers the question that hung over Bun for years: this project isn't going away.

npm

npm is the default, and defaults have real value. It ships with Node, every tutorial assumes it, every CI image has it, and every package on the registry was tested against it. If you never think about your package manager, you're using npm and nothing is wrong with you.

The costs are just quietly accumulating. npm 11 is the slowest of the four: 14.3 seconds for a cold install of a 50-dependency project in January 2026 benchmarks, against 0.8 for Bun and roughly 3 for pnpm. It duplicates every package into every project's node_modules, so ten projects on your machine can mean 5GB of copies of the same packages. And its flat node_modules layout allows phantom dependencies: your code can import a package you never declared, because something else installed it nearby. That works right up until a minor update removes it, and then you're debugging a failure in code you didn't change.

Who should not use npm: anyone with more than a couple of projects on one machine, and anyone whose CI bill scales with install time. Which, if you're reading this site, is probably you.

pnpm

pnpm fixes npm's two structural problems without changing your workflow, and that combination is why it's the winner here.

Problem one, disk. pnpm stores every package once in a global content-addressable store and hard-links it into each project. Same node_modules layout your tools expect, a fraction of the footprint. Across ten projects, roughly 5GB of npm duplication drops to about 1.5GB. On a laptop where I keep every client project and half-finished side project ever started, this alone justified the switch.

Problem two, correctness. pnpm's symlinked structure means your code can only import what package.json declares. Phantom dependencies fail immediately at install time instead of six months later in production. This is the unglamorous feature that has quietly made pnpm the default for serious monorepos.

Speed lands close behind Bun's headline numbers among Node-native options: about 3x faster than npm cold, and on a large project's warm install, 8.4 seconds against npm's 24.6. Adoption removes the ecosystem risk: 65 to 72 million weekly downloads in 2026, Vite and most modern frameworks recommend it, and pnpm 10's script-blocking security default is the best in class. Migration from npm is genuinely two commands: pnpm import converts your existing lockfile, pnpm install takes it from there. Even Laravel devs get the benefit for free: every Laravel app carries a package.json for Vite, and pointing it at pnpm shaves the frontend install in local dev and CI alike.

Who should not use pnpm: teams relying on packages that secretly depend on hoisted flat node_modules. They exist, they're rare, and pnpm has escape hatches (shamefully-hoist), but if you hit one on day one, the strictness that's usually a feature will feel like a fight.

Yarn

Yarn deserves a respectful, honest assessment, because the engineering is genuinely impressive and the trajectory is genuinely down.

First, the split that confuses everyone: Yarn Classic (v1) and Yarn 4 (Berry) are effectively different products. Classic is frozen, receiving security patches only. It's still installed on millions of machines out of 2016-era habit, and it should not start a new project in 2026. Yarn 4 is the real product: Plug and Play eliminates node_modules entirely, mapping imports straight to a cache of zip archives, and zero-installs mean a fresh clone can run with literally no install step. When the whole toolchain cooperates, it's the fastest CI story in JavaScript. Discord runs it and reported a 60 percent cut in build-server disk usage.

The problem is the word "cooperates." PnP still hits compatibility gaps with tools that expect a physical node_modules folder, and every gap costs you an afternoon. Meanwhile the migration math works against Yarn: teams leaving Classic face a real migration either way, and most pick pnpm because it delivers similar benefits with fewer edge cases. State of JS retention data shows pnpm pulling ahead of Yarn for the second year running. Yarn isn't dying. It's becoming a specialist tool for teams that specifically want zero-installs and will maintain the plugin setup that makes PnP smooth.

Who should not use Yarn: anyone not already invested in it. If you're choosing fresh in 2026, the honest answer is that this race is between pnpm and Bun.

Bun

Bun's package manager is the fastest thing in the category and it's not close. Written in Zig, using a binary lockfile and a fraction of the system calls npm makes, bun install finished the 800-dependency benchmark monorepo in 4.8 seconds. npm took 134. Even warm, Bun is several times quicker than everything except Yarn's zero-install trick, which cheats by committing dependencies to the repo.

And the existential question got answered in December 2025: Anthropic acquired Bun, keeps it MIT-licensed and open source with the same team, and ships Claude Code as a Bun executable to millions of users. A company with a billion-dollar product riding on this runtime has every incentive to keep it excellent. I covered what the acquisition means for the runtime side in my Bun vs Node vs Deno comparison; the short version is that Bun graduated from "exciting bet" to "infrastructure."

So why isn't it the default pick? Because bun install is the gateway to the Bun runtime, and that's a bigger decision than a package manager swap. Node compatibility sits around 95 percent, which sounds high until you're the 1 in 20. Native addons built with node-gyp don't work at all, which can bite on database drivers, image processing, and crypto packages. The binary bun.lock is incompatible with the other three, so the way back has friction. None of this is disqualifying. It just means Bun makes most sense when you're using Bun as your runtime anyway, where you'd also collect the bundler, test runner, and the speed everywhere else.

Who should not use Bun: existing production apps with deep native dependencies, and teams that want the package manager decision to stay a small decision.

How Much Faster Are We Actually Talking?

Numbers from January 2026 benchmarks on Apple Silicon (Pockit, cross-checked against pnpm's own published benchmarks), cold installs with no cache:

Scenario	Bun	pnpm	npm
50 dependencies, cold	0.8s	~4s	14.3s
800-dep monorepo, cold	4.8s	~20s	134s
800-dep monorepo, warm	1.2s	8.4s	24.6s

Yarn 4 sits between pnpm and npm on conventional installs, but its real play sidesteps the table entirely: with Plug and Play zero-installs, dependencies are committed to the repo, so a fresh clone starts in zero seconds at the cost of repository size.

Two honest caveats. Benchmark numbers swing with network, hardware, and cache state, so treat the ratios as real and the absolute numbers as indicative. And for CI, the biggest win isn't switching managers, it's caching the global store (~/.pnpm-store or ~/.bun/install/cache) keyed on your lockfile hash, which routinely takes installs from 30 seconds to under 2 regardless of manager.

Does a 13-second difference per install matter? Multiply it by every developer, every CI run, every day, for the life of the project. For a solo dev shipping a Next.js or SvelteKit app, it's minutes a day. For a monorepo with heavy CI, it's real money.

How Do You Choose?

The decision is simpler than four options suggest, because two of them resolve themselves. Yarn only makes sense if you're already committed to it. npm only makes sense if you refuse to install anything, which is a legitimate position for a tiny project or a tutorial.

That leaves the real question: is your runtime Node or Bun? If Node, use pnpm and stop thinking about this. If you're building greenfield on the Bun runtime, use bun install and collect the whole toolkit. The one rule that beats every benchmark: pick one per project and enforce it, because a repo where half the team runs npm and half runs pnpm generates lockfile conflicts that erase every second any tool saved. Add a packageManager field to package.json and let the tooling enforce it.

View the interactive diagram on devtoolpicks.com

Final Recommendation

Use pnpm. It's the best package manager for most indie hackers in 2026: 3x faster than npm, two thirds less disk across projects, strict enough to catch real bugs, compatible enough to never fight you, and a two-command migration away.

Use Bun when you're all-in on the Bun runtime, which post-acquisition is a safer bet than it's ever been. Keep npm for throwaway projects and tutorials. And if you're on Yarn Classic in 2026, migrate somewhere this quarter, just probably not to Yarn 4.

The frontend framework debates get all the attention, like Astro vs Next.js did this month. But the package manager runs before any of that code does, on every install, forever. It's worth ten minutes of deliberate choice.

Still on npm out of habit, or did something here change your mind? Tell me on Twitter @devtoolpicks.

Grok 4.5 Launch Review: The Cheapest Frontier Coding Model for Indie Hackers in 2026?

DevToolsPicks — Thu, 09 Jul 2026 12:13:16 +0000

Originally published at devtoolpicks.com

xAI shipped Grok 4.5 on July 8, 2026, and unlike a couple of frontier launches this year, this one is actually available. It's live right now in Grok Build, inside Cursor on every plan, and through the xAI developer console with an API key. (Quick naming note: xAI is legally SpaceXAI since SpaceX absorbed it in February, but the API is still grok-4.5 and everyone still says xAI, so I will too.)

Elon Musk is calling it "an Opus-class model, but faster, more token-efficient and lower cost." The first half of that is marketing. The second half is the part indie hackers should care about, because it's true and it changes the math on your API bill.

My take upfront: don't switch blindly, but test it. Grok 4.5 is not the most capable coding model available, it trails Claude Fable 5 and Opus 4.8 on the hardest benchmarks. But at $2 input and $6 output per million tokens, with genuinely fewer tokens burned per task, it might be the cheapest way to get near-frontier coding quality in 2026. For a bootstrapped SaaS watching every dollar of API spend, that's the whole ballgame.

What Is Grok 4.5?

Grok 4.5 is xAI's new flagship, the first model built on its 1.5-trillion-parameter V9 foundation, roughly three times the scale of the V8-small architecture behind earlier Grok 4 builds. It was trained across tens of thousands of NVIDIA GB300 GPUs, and the interesting part: xAI folded in real developer session data from Cursor during supplemental training. Debugging traces, multi-file diffs, user corrections. That's a different training signal than the static code corpora most models learn from, and it's the reason the launch leans so hard into "coding and agentic work."

The Cursor connection isn't a coincidence. SpaceX agreed in June to acquire Anysphere, the company behind Cursor, in a $60 billion all-stock deal. Grok 4.5 is the first visible output of putting a model lab and a popular IDE under one roof. If you already looked at Grok Build when it launched, this is the model now running inside it by default.

The headline specs: a 500,000-token context window (smaller than Grok 4.3's 1M, worth noting if you rely on huge contexts), around 80 tokens per second, text and image input, and the full modern tool-use stack with function calling, structured outputs, and code execution.

How Much Does Grok 4.5 Actually Cost?

This is the part that matters. Grok 4.5 is $2 per million input tokens and $6 per million output tokens, with cached input around $0.50.

Put that next to the competition:

Model	Input (per 1M)	Output (per 1M)
Grok 4.5	$2	$6
Claude Opus 4.8	$5	$25
Claude Sonnet 5	$3	$15
GPT-5.6	$1	$6

Grok 4.5 lands at 40% of Opus 4.8's input price and 24% of its output price. On the standard workload I use for these posts (1,000 API calls a day at 1,500 input and 800 output tokens, about 45M input and 24M output tokens a month), the naive per-token cost comes out around $234 a month for Grok 4.5 against roughly $825 for Opus 4.8. GPT-5.6 is fractionally cheaper on paper at about $189, but that's before you factor in the thing that actually separates Grok 4.5 from the pack.

Why Token Efficiency Is the Real Story

Per-token price is only half the bill. The other half is how many tokens a model burns to finish a task, and this is where Grok 4.5's Cursor training shows up.

xAI reports that on SWE-Bench Pro, Grok 4.5 resolves tasks using an average of 15,954 output tokens, against 67,020 for Opus 4.8 in max mode. That's about 4.2x fewer tokens for the same job. Stack that on top of the cheaper per-token rate and the gap widens dramatically: a resolved task costs roughly $0.10 of output on Grok 4.5 versus about $1.68 on Opus 4.8 in max mode. Call it 17x cheaper per completed coding task.

Be skeptical of that exact multiple, because it's one benchmark, measured by the vendor, and Opus's "max" mode deliberately reasons at length (which is partly why it wins the harder benchmarks). But the direction is real and independently supported: Artificial Analysis measured Grok 4.5 at roughly $2.59 per coding task on its Intelligence Index, against about $11.80 for Fable 5. For anyone running thousands of agentic coding operations a day, that's the difference between a bill you shrug at and a bill you dread.

The terse-model insight is worth internalizing: a cheap model that finishes in fewer tokens can beat a pricier, chattier model by more than the price sheet suggests. Sometimes, though, the chattiness is the point, since the extra reasoning is why the expensive model gets the hard ones right.

What Do the Benchmarks Actually Say?

Here's where I have to separate what xAI claims from what's defensible. Musk posted that Grok 4.5 hit #1 on multiple benchmarks. xAI's own launch page tells a more honest, more useful story.

Across the four coding benchmarks xAI chose to publish, Grok 4.5 beats Opus 4.8 on two (DeepSWE 1.0 and Terminal-Bench 2.1) and loses on two (DeepSWE 1.1 and SWE-Bench Pro). On SWE-Bench Pro it scores 64.7% against Opus 4.8's 69.2% in max mode, and Fable 5 leads the whole table at 80.4%. The pattern holds on the independent read: Artificial Analysis ranks Grok 4.5 #4 of 168 models on its Intelligence Index with a score of 54, behind Fable 5 (60), Opus 4.8 (56), and GPT-5.5 (55).

So "Opus-class" is a fair label for a model that splits four head-to-heads roughly evenly. "Beats Opus," which is how the quote is getting repeated across the launch-day cycle, is not what the chart shows. What Grok 4.5 clearly wins is terminal-based agentic work (Terminal-Bench 2.1 at 83.3%), which maps to DevOps automation, CLI workflows, and unattended coding agents. If that's your workload, this is a genuinely strong tool. If you're doing repository-scale bug fixing across large codebases, Opus 4.8 still has the edge.

One honest caveat that hasn't been independently tested yet: several launch writeups flag a hallucination rate worth watching. Verify on your own tasks.

Who Should Actually Use Grok 4.5?

Use it if cost and speed are your top constraints and your workload is high-volume agentic coding. At 80 tokens per second, roughly 4x fewer tokens per task, and a low per-token price, nothing else in this quality tier is close on total cost. Terminal-heavy and CLI-driven workflows are its sweet spot. And if you're already in Cursor or Grok Build, it's right there as the default, no migration required.

Don't use it as your only model if you're doing expensive-to-get-wrong work: the hardest autonomous engineering tasks, security-sensitive code, anything where a subtle wrong answer costs more than the tokens saved. For that, Opus 4.8 or Fable 5 earn their premium. And if you're in the EU, you're waiting regardless: Grok 4.5 wasn't available there at launch, with xAI targeting mid-July.

The realistic play for most indie hackers is a router, not a switch. Send the high-volume, cost-sensitive agentic work to Grok 4.5, keep a fallback to Opus or Fable 5 for the tasks that justify the price. I laid out that same logic in the Claude Sonnet 5 launch review: the right question in 2026 isn't "which model wins," it's "which model for which task."

View the interactive diagram on devtoolpicks.com

Final Verdict

Grok 4.5 is the most interesting launch of the month for cost-conscious builders, and the least interesting for anyone chasing the top of the leaderboard. It's not the best coding model in 2026. It might be the best value, which for a bootstrapped SaaS is often the number that actually decides things.

Test it before you trust it. Run your real prompts and real code against Grok 4.5 and whatever you're using now, compare quality and total cost per task, and route accordingly. If your API bill has been creeping up on agentic coding, this is worth an afternoon of evaluation this week. If you're choosing your AI coding IDE around it, my best AI coding tools breakdown covers how these models plug into daily workflows.

Tested Grok 4.5 on real work yet? Tell me what the token bill looked like on Twitter @devtoolpicks. Launch-day benchmarks are one thing, your actual usage is another.

Best Heroku Alternatives for Indie Hackers in 2026 (Now That Heroku Stopped Building)

DevToolsPicks — Thu, 09 Jul 2026 04:40:09 +0000

Originally published at devtoolpicks.com

On February 6, 2026, Heroku published a blog post announcing its move to a "sustaining engineering model." Translated from corporate: security patches continue, new features stop, and Salesforce won't sign new Enterprise contracts. Your dynos keep running. The platform stops moving.

That announcement settles a question indie hackers have been circling since the free tier died in November 2022. It's not "is Heroku too expensive?" anymore. It's "why pay premium prices for a platform in maintenance mode?" A small always-on app with a worker, Postgres, and Redis costs about $22 a month on Heroku, and the number only grows from there: the first real production tier of Postgres alone is $50.

My pick for most people is Railway. It's the closest thing to the Heroku workflow, usually at half the price. But there are four destinations worth knowing, and the right one depends on how much ops work you're willing to own.

Quick Verdict

Tool	Best For	Price	Rating
Railway	Closest Heroku experience	$5/mo Hobby + usage, ~$10-20 real	9.1/10
Render	Predictable plan-based pricing	Free tier, services from $7/mo	8.7/10
Fly.io	Multi-region and edge apps	Pay-as-you-go, ~$10-20 small app	8.2/10
Coolify + Hetzner	Lowest cost, full control	Free self-hosted + €5.49/mo VPS	8.6/10

What Does "Sustaining Engineering" Actually Mean for Your App?

Nothing breaks tomorrow. Heroku's own announcement is explicit: credit card customers, existing and new, keep the same pricing, billing, and service. Apps, pipelines, and add-ons all keep working.

What changes is the trajectory. No new features means the platform slowly drifts behind: new language runtimes arrive late or never, the developer experience stays frozen in 2023, and compliance capabilities stop evolving. Salesforce is pointing its investment at AI products instead. There's a telling precedent inside the same announcement: Enterprise sales are closed to new customers, which is historically how large companies begin a multi-year product wind-down.

So the migration question isn't urgent. It's directional. If you're starting something new, you shouldn't start it on Heroku. If you're running something old, you have time to move deliberately, and the four options below cover every migration style.

Railway

Railway is what people mean when they say "the new Heroku." Connect a GitHub repo, Railway detects the framework and builds it, no Dockerfile needed. Postgres, MySQL, Redis, and MongoDB are one click each. Preview environments spin up per pull request. It's the same push-and-forget promise, executed with a 2026-grade dashboard.

Pricing is the part to actually understand. There's a 30-day trial with a one-time $5 credit, then plans start at Hobby, $5 a month with $5 of usage included. Usage is billed per second on what your containers actually consume: roughly $20 per vCPU and $10 per GB of RAM per month at full utilization. A small Laravel or Node app idling at 100MB of RAM costs very little; the $5 Hobby credit genuinely covers light projects. A realistic small production setup, web service, worker, and a modest Postgres, lands around $10 to 20 a month. Compare that to $22 minimum on Heroku for less flexibility. Railway's own pricing page quotes a customer who cut hosting costs 75% moving off Heroku. Pro is $20 per seat with $20 of usage included when you need teammates.

The honest cons. Usage-based billing cuts both ways: a memory leak or a traffic spike shows up on your invoice, and Railway has no hard spending cap below the plan level, so set up usage alerts on day one. Reliability has also had wobbles; a December 2025 incident paused builds across the EU West region, and uptime-sensitive teams should read the status page history before committing. I compared Railway head to head with the other managed options in my Railway vs Render vs Fly.io comparison if you want the full breakdown.

Who should not use Railway: anyone who wants a fixed, predictable invoice. That's Render's job.

Render

Render is the plan-based counterpart. Instead of metering your usage, you pick an instance size per service and pay that number. A Starter web service is $7 a month, always-on, no sleeping. Managed Postgres starts at $6. Background workers and cron jobs are first-class service types. The mental model is Heroku's, with prices from a decade earlier.

Render is also the only managed option here with a real free tier: free web services (they spin down after 15 minutes of inactivity and take up to a minute to wake, very Eco-dyno energy), 750 free instance hours a month, free static sites, and a free 1GB Postgres. The catch you must know: free Postgres databases are deleted after 30 days. Not paused. Deleted. Prototype on it, but put anything you care about on the $6 paid tier.

One 2026 change makes Render better for small teams: workspace plans dropped per-seat billing. Hobby workspaces are free, and the Pro workspace is a flat $25 a month with unlimited members, replacing the old $19-per-user Professional plan. Legacy workspaces migrate automatically by August 1, 2026. If you read an older comparison complaining about Render's seat fees stacking up, that complaint is now outdated.

So a Heroku-equivalent stack, web service $7, worker $7, Postgres $6, comes to about $20 a month on a free Hobby workspace, roughly matching Heroku's price with a modern platform that's actively shipping. The trade against Railway: less efficient for spiky or idle workloads, since you pay for the instance whether it's busy or not.

Who should not use Render: high-bandwidth apps on the cheap tiers. Included bandwidth is limited and overages add up, so check the numbers if you serve heavy media.

Fly.io

Fly.io is the option for a specific reason: running your app in multiple regions, close to users. Machines are micro-VMs deployed across 30+ regions with anycast routing. If your users are split between the US, Europe, and Asia and latency is a product feature, nothing else on this list does what Fly does.

Pricing is pure pay-as-you-go, billed per second. The smallest always-on machine (shared CPU, 256MB) is about $1.94 a month, volumes are $0.15 per GB, and a realistic single-region production app with a database lands in the $10 to 20 range. Know the 2026 fine print: there's no free tier for new accounts anymore (the old three-free-VMs allowance is grandfathered for legacy users only), dedicated IPv4 addresses cost $2 a month per app, and volume snapshots started incurring charges in January 2026.

The bigger caveat is operational. Fly's classic Postgres is not a managed database; it's Postgres running on your machines, and backups, upgrades, and failover are your responsibility (a managed Postgres offering exists, billed separately). Fly also assumes more comfort with infrastructure thinking, machines, volumes, regions, than either Railway or Render. Coming from Heroku's fully managed world, that's a real step, and community threads through 2025 flagged reliability grumbles alongside the pricing changes.

Who should not use Fly.io: single-region apps that just need a web server and a database. You'd be taking on infrastructure complexity for a multi-region capability you're not using.

Coolify + Hetzner

This is the money option. Coolify is an open source, self-hosted platform: install it on any VPS and you get git-push deploys, automatic SSL, preview environments, and one-click Postgres, Redis, and 300+ other services, on hardware you control. It crossed 55,000 GitHub stars in 2026, making it the most popular self-hosted PaaS by a wide margin.

Pair it with Hetzner and the economics get silly. A CX23 instance (2 vCPU, 4GB RAM, 40GB SSD) costs €5.49 a month, and that single box comfortably runs a web app, a queue worker, Postgres, and Redis. That's the entire $22 Heroku starter stack, plus room for two more side projects, for roughly the price of one Basic dyno. Even after Hetzner's 2026 price adjustments, nothing managed comes close per euro. Coolify itself is free self-hosted forever; if you want the control plane managed for you, Coolify Cloud is $5 a month for two connected servers.

Now the honest part, because this pitch always sounds too good: you are the ops team. You patch the OS, you configure the firewall, you own the backup strategy, and when the server misbehaves at 2am, there's no support ticket, just you and the logs. Coolify removes maybe 80% of the daily friction, and it's genuinely impressive software, but the remaining 20% is real responsibility that Railway and Render charge you to make disappear. Budget a weekend for initial setup and a couple of hours a month after that.

Who should not use this: anyone whose time is currently worth more than the savings, or who has never secured a Linux server. There's no shame in paying $15 a month to never think about fail2ban.

What Does the Same App Cost on Each?

Take the standard indie stack: one web service, one background worker, a small Postgres, and Redis, running always-on.

On Heroku that's two Basic dynos at $7 each, Essential-0 Postgres at $5, and the Key-Value Mini at $3: $22 a month, with a 1GB database and no failover. On Render, roughly $20 with services that Heroku would charge $25-plus for. On Railway, typically $10 to 20 depending on actual consumption, less if your app idles quietly. On Fly.io, a similar $10 to 20 for one region, growing with each region you add. On Coolify plus a Hetzner CX23, about €6 with an IPv4 address, plus your time.

The pattern: every option is cheaper than Heroku, and every option is on a platform that's still being built. That second part is the one Heroku can no longer say. It's the same trap I covered with Vercel's pricing cliffs: the platform you start on shapes your costs for years, so pick one with a future.

View the interactive diagram on devtoolpicks.com

How Do You Choose?

Start with the ops question, because it filters hardest. If you can run a server, Coolify plus Hetzner wins on cost, especially once a second and third app share the box. If you can't or won't, you're choosing between managed platforms, and the split is billing philosophy: Railway meters what you use, Render charges what you provision. Spiky traffic and idle side projects favor Railway. Steady production traffic and budget predictability favor Render. Fly.io only enters the conversation when multi-region is a genuine product requirement, not a nice-to-have.

And migration effort is lower than you think for all four. Heroku apps are twelve-factor by design: environment variables, a Procfile, a Postgres URL. Every platform here imports that shape almost natively. Export your config with heroku config, capture a database backup with heroku pg:backups:capture, and most single-app migrations finish in an afternoon.

Final Recommendation

For most indie hackers leaving Heroku, use Railway. Same workflow, half the cost, actively developed.

Use Render if you want a fixed number on your invoice and a free tier for prototypes. Use Fly.io only if multi-region latency actually matters to your product. And if you're the kind of person who reads server logs for fun, Coolify on a Hetzner box will host your entire portfolio of projects for less than a Netflix subscription.

Staying on Heroku is the one choice I'd push back on for anything new. The platform works, but you'd be building on ground that's officially stopped moving.

Made the jump already? Tell me where you landed and what the bill looks like on Twitter @devtoolpicks.

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

DevToolsPicks — Tue, 07 Jul 2026 04:15:11 +0000

Originally published at devtoolpicks.com

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

Tool	Best For	Price	Rating
Qdrant	Most indie hackers, cost control	Free 1GB cluster, then provisioned	9.0/10
Pinecone	Zero-ops managed experience	Free, $20/mo Builder, $50/mo min Standard	8.6/10
Weaviate	Hybrid search, all-in-one AI stack	Free 100K objects, $45/mo min Flex	8.4/10

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.

View the interactive diagram on devtoolpicks.com

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.