Blog

The one object that is your worker, and why a framework should hand you the pieces already fitted.

Not just a runtime. A platform your worker, database, queue, and storage all live on together.

Types are the contract that keeps decorators honest and carries a shape across every boundary.

One integrated thing versus four libraries you wire together yourself. Integration over assembly.

A simple idea wearing a heavy name, and the quiet machinery that makes the rest of Base legible.

The vocabulary you decorate your classes with, and how the framework reads them to wire your worker.

The composition unit: a self-contained slice that brings its own services and settings to a worker.

Router decorators that turn a class method into an HTTP route, with the request bound for you.

A code-first GraphQL server where your decorated classes are the schema, no separate SDL to sync.

Call a service method like it is local, and let the framework carry the call across the wire.

One worker calling another as a typed method call, with the interface shared instead of stubbed.

A typed client in the browser that calls your worker as if the service were sitting next to it.

The per-request object that carries what a handler needs, reached the framework way through injection.

The work around your handlers, split by timing: global before the handler is known, handler after.

A first-class relational layer built on Drizzle, entities and repositories reached like everything else.

The Verify decorator family that checks your inputs at the edge before your logic ever sees them.

How a shape becomes bytes on the wire and back again, consistently across REST and RPC.

Two jobs people conflate: one shapes data crossing a boundary, the other decides if it is allowed.

The cryptography surface for protecting data at rest and in transit, without hand-rolling the hard parts.

Object storage behind an S3-compatible interface: declare a bucket once, reach the store by injection.

Edge key-value storage for read-heavy, write-light data, and the caching pattern it is built for.

A typed handoff between two workers: a producer submits and returns, a consumer chews the backlog.

Work that runs on a clock instead of a request, registered with a cron and validated up front.

A stateful, single-instance worker with an address and a memory, reached through a typed handle.

The ORM pointed at the database embedded inside one object: same shape, local, isolated per entity.

The escape hatch for work a worker cannot do: a real container, reached like a durable object.

Live two-way connections that tie into durable objects and RPC, so a socket call stays typed.

Emit an event, let listeners react, and keep the code that causes from the code that responds.

Jest plus worker-shaped helpers, and the two altitudes every healthy test suite is built from.

Test a module in isolation, letting dependency injection resolve the service in a fresh scope.

Stand up the worker and hit its real surface, proving the routing, decorators, and wiring together.

A deep look at BaseSettings: three fields required, every capability beyond that an optional key.

Ship a Base worker to Cloudflare, with one description that runs across environments and platforms.

Take the human out of shipping: push code, run the gates, deploy the same way every time.

One decorated class that is both your TypeScript type and your GraphQL type, so they cannot drift.

The server interface is the client contract, shared as a type, so no codegen and no drift.