The simple services App Engine got right
App Engine gave developers managed services that were quietly excellent — simple, well-documented, and priced for small apps. Some were retired; others stayed, but stricter than they needed to be. altengine exists to offer that same experience as standalone cloud services — on an API of our own, with the constraints that no longer earn their keep taken off.
The gap we're filling
For years, App Engine gave developers things that were genuinely difficult to build yourself: a managed full-text Search API, a realtime Channel API for pushing messages to clients, and a Datastore for schemaless document storage with a real query engine. They were simple, well-documented, and priced for small apps. Then Search and Channel were retired, while Datastore lived on but kept its sharp edges — typed properties instead of plain JSON, no joins, composite indexes declared up front, and eventual consistency outside an entity group.
altengine brings that experience back. For the APIs App Engine retired, we treat parity of semantics as the contract: the query language, field types, facets, and sorting behave the way they always did. What's different is how you reach them — a clean REST/JSON API instead of a language SDK — so migrating means rewriting your call layer, not redesigning your search. For Datastore, we keep the familiar model and loosen the contract where it used to pinch: any JSON object, joins, grouped aggregates, and strongly consistent reads.
The one place we went past the original is identity. App Engine let you lean on Google accounts and little else, so most apps ended up writing a users table and a session layer by hand. Our Auth API gives you your own end users instead — accounts, sign-in, and short-lived identity tokens — plus row-level access rules that let a browser talk to Datastore and Channel directly as that user. It's the piece that turns three storage and messaging services into something you can build a whole app on without running a backend.
What we're building
- Search API — structured documents, a query language faithful to the original, facets, sorting, and pagination.
- Channel API — subscribe-only client sockets (one socket carries many channels), HTTP publish, and fan-out to subscribers.
- Datastore API — schemaless JSON documents, a bounded query engine with joins and grouped aggregates, atomic transactions, and point-in-time restore.
- Auth API — end-user accounts with a sign-up form you configure, password, passwordless, 2FA and passkey sign-in, and row-level access rules that let clients reach your data directly.
- Functions — sandboxed server-side JavaScript for the work a browser must not be trusted with, on a URL of its own, with schedules and bindings to the services above.
- Blob API — file storage where the bytes never pass through the API, with a permanent public URL for what you publish and free bandwidth for serving it.
- Containers — a Docker image you choose, run as a background job for as long as the work takes, for the things a function's seconds cannot hold.
These are where we started, not the ceiling. altengine begins with App Engine–style services — reviving retired APIs and offering standalone takes on the ones that stayed — but it isn't limited to them, and the last three on that list have no App Engine ancestor at all. We add services as demand shows up, so if there's a capability you'd run, tell us and it helps us prioritize.
Principles
Parity of semantics is the contract. The developer-facing behavior stays faithful to what App Engine offered — same concepts, same query language, same results. We won't pretend it's a zero-code migration: you call a REST API rather than an SDK. But nothing you learned about modelling search has to change.
Affordable by default. Managed search has usually meant paying for a cluster — provisioned nodes you're billed for even when they sit idle — or a hosted service whose price climbs steeply once you pass a thousand documents. altengine has no cluster to keep running. You're billed for the storage your documents and index use, plus the searches you run — so an index you aren't querying costs only its storage.
The first $3 is free. There's one plan — pay-as-you-go — and the first $3 of usage each month is on us. Most side projects never pay a cent, and idle resources cost effectively nothing.
Secure by construction. Short-lived, per-instance signed tokens and least-privilege, org-scoped grants are part of the model — not an add-on.
Who it's for
Teams migrating off legacy App Engine, developers who miss a search, realtime, document-store, or sign-in service that just works, and anyone who wants managed capabilities without managing a cluster or a five-figure invoice.