Published August 12, 2026 · altengine team

The Cheapest Managed Full-Text Search for Small Apps

For a small app, the cheapest managed search is the one with no monthly floor — because your bill is dominated by idle time, not by traffic. On altengine there's no cluster to rent and the first $3 of usage each month is free, so a few-thousand-document catalog serving tens of thousands of searches typically costs nothing at all. Below is the arithmetic, the point where you start paying, and the levers that move the number.

Why "small" is the hard case for search pricing

A small app has an awkward shape: a catalog of a few thousand documents, traffic that's bursty and mostly idle, and a budget that's a rounding error. Almost every hosted search product is priced for one of two other shapes.

• Rent-a-cluster. A node runs around the clock and you pay by the hour whether or not anyone searches. Elastic Cloud, AWS OpenSearch, Typesense Cloud, and Meilisearch Cloud all work this way. The bill has a floor — the cost of keeping the lights on — and for a small app that floor is the bill.
• Per-record and per-search. No cluster to think about, but you're metered on how many records you store and how many searches you run. Algolia is the best-known example, and it's the model closest to altengine.

Neither is wrong; both are aimed past you. Renting a node makes sense when you can keep it saturated. Per-record pricing makes sense when your records are big and few. A small app is the opposite of both: an index that sits idle most of the day, made of many small documents.

For reference, the smallest realistic running configuration of each cluster-based service came out at roughly $22 (Typesense Cloud), $26 (AWS OpenSearch), $30 (Meilisearch Cloud's Build plan), and $95 (Elastic Cloud) a month when we checked list prices in July 2026 — before a single query. Algolia has no fixed floor and a real free tier (10,000 searches and 100,000 records a month), then bills usage. We worked all of this through in detail in what managed search really costs; this post is the small-app slice of it.

What a small catalog actually costs

altengine bills Search on four axes: a flat fee per query, reads for the rows a query examines, writes for the rows a document put creates, and stored data by the gigabyte. There is no fifth line for capacity, because there's no cluster.

Take a concrete small app: a 5,000-document product catalog averaging ~1.5 KB each (about 7 MB of content), 20,000 searches a month, and 2,000 document updates a month.

Two of those lines deserve a note. Reads are metered by rows examined — one read covers up to 100 rows — so a selective query over an indexed field costs a read or two, and a repeated identical query is served from cache and bills zero reads, just its query. Writes are the estimate with the most spread: putting a document writes its own row plus its full-text and field index rows, so the per-document row count depends on how big the document is and how many indexed values it carries. The ~30-rows-per-document assumption above is illustrative; a lean document is cheaper and a fat one is dearer. Loading the initial 5,000 documents bills the same way, once — on that assumption, about $0.38 for the whole import.

Everything in that table adds up to roughly $1.20, which is under the $3 that's free every month, so the invoice is zero. That's not a promotional tier that expires — it's the first $3 of usage every month, for every organization, with no card required to start.

So when do you actually start paying?

Queries are the line that grows fastest for a read-heavy app, and at $0.50 per 10,000 the $3 works out to about 60,000 searches a month on its own. Leave room for reads, writes, and storage and the real crossover for a small catalog sits somewhere around 50,000–55,000 searches a month — call it 1,700 searches a day. Past that you pay only the amount above $3, so 100,000 searches on the same catalog is roughly $5.20 of usage and about $2.20 on the invoice.

Five levers that keep it near zero

Because you're billed for work done rather than capacity held, the cost is something you control. In rough order of impact:

• Index only what you search on. A document's write cost and its storage both scale with the indexed values it carries. Put the fields you query, facet, and sort on into the index and keep the rest in your own database — this is the single biggest lever on both writes and stored data.
• Let repeated queries hit the cache. An identical query bills no reads at all. Stable default views — the empty query on a listing page, a category facet everyone clicks — are effectively query-fee-only. A write to the index invalidates the cache, so you never get stale results in exchange.
• Don't buy an exact count you don't render. total_hits_accuracy defaults to 20 and goes to 10,000; counting matches exactly means examining rows, and reads are metered by rows examined. If your UI shows "N+" rather than a precise total, leave the default alone.
• Leave stemming off unless you need it. It's off by default on an instance precisely because it costs extra storage. Synonyms, by contrast, are instance configuration that costs no storage and needs no reindex — the dictionary rewrites the parsed query — so reach for those first when relevance needs help.
• Delete what you're not using. Dropping an index is free, and deleting the last document in an index removes the index itself, so abandoned experiments don't linger on the bill. There's no idle capacity charge either: a staging index you query once a week costs only its storage.

Here's the cheap shape in practice — a selective, fielded query with a small page and the default count accuracy:

POST /v1/search/catalog/ns/_default/idx/films/search
Authorization: Bearer ae_yourkeyid.your-api-key-secret

{
  "query": "genre:comedy rating > 3",
  "limit": 20,
  "returned_fields": ["title", "rating"]
}

That's App Engine's Search query syntax, unchanged, reached over REST. Full request and response shapes are in the Search API reference.

The honest comparison

Three things worth saying plainly, because a cost post that only flatters us isn't worth your time:

• Self-hosting is cheaper on paper. Meilisearch or Typesense on a $5 VPS beats every managed price here, and for a small catalog it will work fine. What you're buying with a managed service is not compute — it's not owning upgrades, backups, disk-full pages, and the reindex at 2am. If you enjoy that work, self-host; the arithmetic genuinely favors you.
• Algolia's free tier is real, and generous on records. Under 10,000 searches and 100,000 records a month it's $0, and 100,000 records is a lot of catalog. The models diverge on which resource runs out first: Algolia meters your catalog by record count, altengine by bytes. Small numerous documents favor bytes; few large documents favor record counts.
• A busy, steady workload can make a rented node the cheapest option. If you're running constant heavy traffic against a modest index, a $22 node is excellent value — you're keeping a machine saturated, which is what it's priced for. Usage pricing wins when traffic is spiky, seasonal, or small.

Which is the real answer to "cheapest": it depends on whether your bill is mostly idle time. For a small app, it almost always is.

The rate card, in full

One plan, pay-as-you-go, first $3 of usage each month free for every organization — shared across every service you use, not per-service:

• $0.50 per 10,000 queries — flat, per search request
• $1.00 per million reads — one read = up to 100 rows examined; a cached repeat bills zero reads
• $2.50 per million rows written — a put writes the document row plus its index rows; deletes bill as the rows they remove, and dropping an index is free
• $0.80 per GB-month stored — documents plus their full-text and field index
• No monthly floor, no idle cluster, no card to start

See the pricing page for every service's rates and worked free-tier examples. Search is the first of several App Engine–style managed services here, with more added as demand shows up.

Start free in the console

Competitor figures are public list prices as of July 2026, for the smallest realistic configuration of each service: Algolia, Elastic Cloud, AWS OpenSearch, Typesense Cloud, Meilisearch Cloud. Check them before budgeting. altengine is an independent project and is not affiliated with any of these vendors.