Release Note
Ambiten

Appearance

Ambiten · Open-source Node.js infrastructure

An open-source runtime for multi-tenant Node.js and MongoDB applications.

Keep execution context consistent as your application grows.

Building a backend where tenant identity, database scope, request metadata, and transaction sessions must travel across services? Ambiten provides a defined execution context so participating MongoDB operations can use the appropriate state without passing it manually through every layer.

Ambiten runs inside your Node.js application, on top of the official MongoDB driver. It coordinates context, models, transaction participation, adapters, middleware, and instrumentation. It is not a hosted database or a paid MongoDB aggregation feature.

Free and open source.npm install @ambiten/core

Install Ambiten See One Request Flow What is Ambiten?
Who it is forNode.js teams building multi-tenant APIs, services, and background work with MongoDB.
What it solvesRepeated hand-offs of tenant, request, database, and transaction state across application layers.
How to adopt itStart with the core runtime; add models and framework adapters when your application needs them.
When Ambiten Helps

MongoDB operations are easy to write. Coordinating what surrounds them is harder.

Imagine an API request that creates a record, writes an audit event, and updates another collection. Every operation needs the correct tenant and, inside a transaction, the same active MongoDB session. As an application grows, repeatedly passing that state through controllers and services becomes an additional responsibility to maintain.

Ambiten establishes an execution boundary for the runtime state those participating operations share. You decide where that boundary starts; the runtime helps carry the associated context through supported flows.

When You May Not Need It

Simple applications can stay simple.

If your application only performs a few straightforward MongoDB queries, the official driver may be enough. Ambiten is most relevant when multi-tenancy, transaction continuity, framework integration, and operational context become recurring concerns.

See the complete request flow →

One Runtime Flow

From an incoming request to MongoDB, keep the execution state together.

In many MongoDB applications, the difficult part is not the database call itself. The difficult part is preserving the execution state around that call: which tenant is active, which request or job initiated the work, which database should be used, whether a transaction session exists, which middleware participates, and what runtime metadata should be available to instrumentation.

Ambiten gives those concerns a defined execution path instead of leaving them as repeated plumbing across controllers, services, resolvers, background jobs, and model calls.

Execution BoundaryAmbitenContextAmbitenModelEffective ModelContextSchema / MiddlewareInfrastructureMongoDB
Supported Runtimes

Choose the adapter that matches where your app runs.

ExpressMiddleware entry point for familiar Node.js services and REST APIs.MiddlewareFastifyHook-driven integration for high-throughput APIs with request-scoped context.preHandlerNestJSModule and interceptor wiring for structured applications with clear boundaries.ModuleGraphQLContext factory support for resolver-based execution and schema-first APIs.ResolversAWS LambdaWrapped handlers for serverless, event-driven, and scheduled workloads.Handler
Director Observability

Execution-level operational insight for the systems Ambiten powers.

Director is the planned operational intelligence layer for Ambiten. It is designed to build on structured runtime telemetry and turn execution signals into views around tenant activity, execution scope, transaction outcomes, runtime budgets, latency patterns, and operational behavior.

Director is a planned preview, not a currently available paid product. Ambiten Core provides the execution model and runtime metadata; instrumentation exposes the signals; Director is designed to correlate and present those signals in a form teams can investigate and act on.

Open Director Preview View Instrumentation
Runtime SignalsWhat Director is designed to surface
Tenant activity Compare query volume, latency, runtime budgets, and operational patterns across tenant workloads.
Scope visibility Surface operations without expected tenant or execution identity so teams can distinguish intentional system work from unexpected runtime behavior.
Transaction diagnostics Observe transaction outcomes, abort patterns, durations, and runtime failure signals where corresponding telemetry is available.
execution telemetryquery instrumentationruntime insight
Runtime observability

Execution-aware logging for context-driven systems.

Ambiten Logger is not a console wrapper. It is a runtime-aware observability layer designed to preserve execution context across requests, transactions, adapters, workers, and distributed application flows.

RequestAmbitenContextTransactionInstrumentationLoggerTransports

Context-aware by design

Logs can automatically inherit request IDs, tenant identity, database targets, collection names, and runtime metadata from the active Ambiten context.

Structured runtime telemetry

Every log is treated as structured execution data, making it easier to search, correlate, route, and analyze across production observability systems.

Resilient transport pipeline

Console, rolling files, async batching, HTTP, Elasticsearch, and Loki transports can be composed with retry and circuit breaker protection.

Explore Ambiten LoggerView transports
Why Ambiten Exists

MongoDB applications become harder to reason about when execution state lives everywhere.

Most teams can write CRUD operations. The harder problem appears as the application grows: tenant identity moves through too many layers, transactions depend on nested calls receiving the right session, database scope is reconstructed in different places, and instrumentation loses the execution information needed to explain what happened.

Ambiten addresses that problem by giving execution state a defined runtime path. Models remain focused on persistence operations while context, middleware, provider infrastructure, transaction sessions, and runtime metadata participate around them through explicit responsibilities.

Runtime Experience
      
      await AmbitenContext.withTransaction(async () => {
        const user = await UserModel.create({
          name: 'Amina',
          email: 'amina@team.io'
        });
        await AuditLogModel.create({
          action: 'USER_CREATED',
          userId: user._id
        });
      });

Participating Ambiten model operations can inherit the active transaction session through the execution context. Tenant identity, request metadata, and other execution state can also be inherited when they have been established by the surrounding runtime.

Product Delivery

Keep feature code focused on application intent.

Ambiten reduces the amount of execution state that application code must manually carry through every workflow. Context belongs to the runtime, persistence state belongs to the model operation, and infrastructure resolution stays behind defined provider boundaries.

Platform Discipline

Give runtime responsibilities explicit owners.

Context propagation, transaction participation, tenant-aware infrastructure, middleware, lifecycle behavior, and instrumentation each have defined places in the runtime instead of depending entirely on conventions repeated across application code.

Runtime Portability

Use one persistence model across different execution environments.

Ambiten's adapter model allows the same application and persistence layer to participate behind REST APIs, GraphQL resolvers, NestJS services, Lambda handlers, background workers, and explicit runtime boundaries.

Capability Surface

What Ambiten adds around ordinary MongoDB data access.

Ambiten is not only concerned with how documents are created, read, updated, or deleted. Its value is in the execution model around those operations: context propagation, model binding, provider resolution, transaction participation, framework integration, tenant-aware infrastructure, and operational metadata.

Execution-scoped state Tenant, request, database, session, and runtime metadata can remain available across asynchronous execution through AmbitenContext.
Progressive adoption Start directly with AmbitenClient, then add models, context, adapters, multi-tenancy, and transaction boundaries as application requirements grow.
Adapter portability Establish the same runtime model across Express, Fastify, NestJS, GraphQL, Lambda, workers, and explicit execution flows.
Transaction participation Participating operations can inherit the active MongoDB session when executed inside a compatible transaction boundary.
Provider-based resolution Models retain their collection boundary while provider infrastructure resolves the database, MongoDB client, and active session required by the operation.
Operational visibility Instrumentation can consume tenant, request, operation, and runtime metadata without requiring every application layer to reconstruct it.
Explore The Runtime

Start with one execution, then understand the system behind it.

Follow execution through adapters, context, model binding, middleware, infrastructure resolution, and MongoDB. From there, go deeper into multi-tenancy, transactions, instrumentation, deployment, and the operational intelligence Ambiten is designed to support.

One Request Flow Architecture

Context-aware execution infrastructure for multi-tenant systems.

Copyright © 2026 Ambiten