ekoDB White Paper
ekoDB: An Agentic Backend Platform on a Multi-Model Database
By Sean M. Vazquez, Creator of ekoDB
Executive Summary
ekoDB is an agentic backend platform built on a multi-model database. The database engine is the foundation: documents, key-value, full-text and vector search, real-time subscriptions and durability in one system. Functions and AI agents are the platform layer on top of it. A function is server-side logic you define once; your app calls it as an API, and your agents find and call it as a tool, under the same permission checks. This paper describes the engine first, then the platform built on it.
The engine is a ~50MB binary that replaces your document store, cache, search engine, vector database, server-side functions, and auth service. Built from scratch in Rust for memory safety and bare-metal performance, it combines in-memory speed with full durability guarantees through Write-Ahead Logging (WAL) — no garbage collector pauses, no null pointer crashes, no data races.
No separate Redis for sessions, no Elasticsearch for search, no Pinecone for vectors, no custom auth middleware. One binary, one API, one set of client libraries across five languages.
Performance that matters: ekoDB outperformed each database below on the workload shown, while doing more work per request:
Results from the 2026-02-16 YCSB comparison run. Full results for that run: Detailed YCSB Benchmarks. Current published run: Performance Benchmarks.
| What ekoDB Replaces | ekoDB | Competitor | Advantage |
|---|---|---|---|
| PostgreSQL (writes) | 39K ops/sec | 5K ops/sec | 7.3x faster |
| MongoDB (writes) | 39K ops/sec | 11K ops/sec | 3.7x faster |
| PostgreSQL (reads) | 124K ops/sec | 107K ops/sec | 15% faster, ~2x less CPU |
| Redis (writes) | 39K ops/sec | 6K ops/sec | 6.5x faster |
| MySQL (writes) | 39K ops/sec | 2.5K ops/sec | 15.7x faster |
| Redis (features) | Auth, encryption, search built-in | None included | Full stack in one binary |
YCSB benchmarks, 2026-02-16 comparison run: 1M records, 64 threads, full durability, 6 databases tested, with Redis in appendfsync=always so every engine is measured under the same persistence guarantee. Every ekoDB request includes JWT auth, AES-GCM encryption, full-text indexing, and vector indexing — work that competitors skip entirely. The current run and the full workload-by-workload breakdown are at https://docs.ekodb.io/reference/performance.
Use less, get more: in the same run, ekoDB's key-value path did roughly 2-6x more work per unit of CPU than PostgreSQL, MongoDB and MySQL on every workload. Redis is the exception and wins on this measure: it saturates a single core by design, where ekoDB spreads across several to carry auth, encryption and search on every operation. That means smaller cloud instances, lower monthly bills, and more headroom for your application — not your database.
Scale Your Way
Run one ekoDB for your entire application, or run many. Connect multiple ekoDB instances via Ripple for cross-region replication, use Functions for server-side business logic — from simple queries to full workflow orchestration with AI, caching, and graph traversal — or orchestrate from your own application API. Start with a single node and scale horizontally as your needs grow — no re-architecture required.
Less to Learn, More to Build
One query language. One set of client libraries. All capabilities listed below accessible through the same API. Your team learns one database instead of five.
Key Capabilities:
- Multi-Model Architecture: Document storage, key-value, full-text search, vector search, real-time subscriptions, and server-side functions in a single system
- Functions and Agents: One function serves as your app's API and your agents' tool, with the same permission checks on both
- Proven Performance: 37-127K ops/sec with full durability in the 2026-02-16 run. ekoDB leads PostgreSQL, MongoDB, MySQL and Redis on write-heavy and mixed YCSB workloads; on read-only point lookups, PostgreSQL and ekoDB trade the lead. Current figures: Performance Benchmarks
- Configurable Durability: Non-durable mode for high throughput or durable mode for guaranteed persistence
- Adaptive Scaling: Deployments from IoT devices to enterprise servers
- Secure by Default: HTTPS/WSS-only, AES-GCM encryption at rest, TLS/SSL in transit
- Adaptive Memory: 1%-80% of available RAM with automatic management
- Distributed: Ripple system for horizontal scaling and cross-database propagation
- Server-Side Logic: Composable Functions for business logic, AI workflows, SWR caching, graph traversal, and external API calls — executed server-side in a single request
- Memory-Safe Foundation: Built entirely in Rust — no garbage collector pauses, guaranteed memory safety
1. Introduction
1.1 The Problem
Applications often require multiple database systems to handle different workloads:
- MongoDB for document storage
- Redis for caching and real-time data
- Elasticsearch for full-text search
- Pinecone for vector search
- PostgreSQL for relational data
This multi-database approach introduces complexity, operational overhead, and integration challenges.
1.2 The Solution
ekoDB consolidates the capabilities described in the Executive Summary into a single Rust binary — managed through a unified API with client libraries across five languages.
1.3 History
ekoDB originated from a practical challenge: integrating multiple databases required complex layers of abstraction to achieve feature parity and consistent usage patterns.
Development Timeline:
- 2013: Initial development as SOLO (Single Object Language Operator), an API gateway for multi-database integration
- 2013-2022: SOLO operated as an API gateway connecting various database systems
- 2022: Decision to eliminate the abstraction layer and build a unified database
- 2022-2025: Complete from-scratch rewrite as ekoDB
- Current: Active development and production use
2. Architecture
2.1 Storage Architecture
ekoDB uses a hybrid in-memory architecture with disk persistence:
┌─────────────────────────────────────────┐
│ In-Memory Layer (Hot Data) │
│ ┌────────────────────────────────────┐ │
│ │ High-performance storage │ │
│ │ optimized for fast access │ │
│ └────────────────────────────────────┘ │
└─────────────────────────────────────────┘
↕
┌─────────────────────────────────────────┐
│ Cache Layer (Warm Data) │
│ ┌────────────────────────────────────┐ │
│ │ Automatic caching with │ │
│ │ intelligent eviction │ │
│ └────────────────────────────────────┘ │
└─────────────────────────────────────────┘
↕
┌─────────────────────────────────────────┐
│ Disk Persistence (Cold Data) │
│ ┌────────────────────────────────────┐ │
│ │ Durable storage │ │
│ │ - Encrypted (AES-256-GCM) │ │
│ │ - Compressed │ │
│ │ - Configurable durability │ │
│ └────────────────────────────────────┘ │
└─────────────────────────────────────────┘
Key Features:
- Larger-than-Memory Support: Datasets can exceed available RAM
- Smart Caching: Frequently accessed data stays in memory for fast access
- Automatic Eviction: Intelligent cache eviction when memory limits are reached
2.2 Data Model
ekoDB supports multiple data models in a unified system:
Document Model
{
"name": "John Doe",
"email": "john@example.com",
"age": 30,
"tags": ["developer", "rust"],
"address": {
"city": "San Francisco",
"country": "USA"
}
}
Key-Value Model
{
"session:user123": {
"token": "abc123",
"expires": "2025-10-15T00:00:00Z"
}
}
Vector Model
{
"content": "ekoDB is a high-performance database",
"embedding": [0.1, 0.2, 0.3, ...], // 384-dimensional vector
"metadata": {
"source": "documentation"
}
}
2.3 Type System
ekoDB provides a flexible type system with per-collection per-field type enforcement:
Note:
- Type enforcement occurs at the time of write and is not enforced at the time of read.
- Type enforcement is optional at key-value level vs required at document level.
- All types are dynamically inferred at write time or can be explicitly specified via
/schemasendpoint.
Supported Types:
ekoDB supports 16 comprehensive data types organized into four categories:
Basic Types
String- UTF-8 encoded text data for names, descriptions, and general text contentInteger- 64-bit signed integers (-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807)Float- 64-bit IEEE 754 floating-point numbers for decimal valuesBoolean- Binary true/false values for logical operations
Advanced Numeric Types
Number- Flexible numeric type that automatically handles both integers and floats, inferred at write timeDecimal- Arbitrary-precision decimal numbers that avoid floating-point rounding errors. Essential for financial calculations (e.g., currency, accounting), scientific computations requiring exact decimal representation, and any scenario where0.1 + 0.2must equal exactly0.3. UnlikeFloat,Decimaluses precision-preserving internal storage, ensuring mathematical precision without binary floating-point approximation issues
Temporal Types
DateTime- RFC 3339 formatted date-time values with timezone support (e.g.,2024-01-01T00:00:00Z)Duration- Time duration values for representing time spans (e.g.,30s,5m,2h)
Collection Types
Array- Ordered lists of heterogeneous elements, preserving insertion orderSet- Unordered collections of unique values with automatic deduplicationVector- Fixed-dimension numeric arrays optimized for embeddings and vector similarity searchObject- Nested documents/maps with key-value pairs for complex structured data
Specialized Types
UUID- Universally unique identifiers (RFC 4122) for globally unique record identificationBinary- Base64-encoded binary data for images, files, and other binary contentBytes- Raw byte arrays for unencoded binary data storageNull- Explicit null/empty values for optional fields
Response Formats:
- Typed: Includes type metadata (e.g.,
{"type": "String", "value": "text"}) - Non-Typed: Traditional NoSQL format (e.g.,
"text")
2.4 Configuration Options
ekoDB provides flexible configuration options to tune behavior for different use cases:
Response Format Configuration
- Typed Responses: Include type metadata for strong typing
- Non-Typed Responses: Traditional NoSQL format for simplicity
- Default: Typed responses (includes type metadata)
- Configuration: Configure via configuration API or ekoDB App (https://app.ekodb.io)
Durability Configuration
- Durable (
durable_operations: true): Guaranteed persistence, every write confirmed to disk - Non-Durable (
durable_operations: false): Higher throughput, async persistence
Storage Mode Configuration
ekoDB provides two storage modes optimized for different workloads:
| Mode | Description | Best For |
|---|---|---|
| Fast | In-memory with WAL durability | Maximum throughput, general workloads |
| Balanced | In-memory with periodic disk persistence | General purpose, mixed workloads |
Fast Mode (storage_mode: "fast"):
- Fastest write and read performance
- Data recoverable from WAL on restart
- Ideal for caches, sessions, and high-throughput ingestion
Balanced Mode (storage_mode: "balanced"):
- Near fast-mode performance with eventual disk persistence
- Good balance of speed and storage efficiency
Configuration Example:
{
"storage_mode": "balanced",
"durable_operations": true
}
Storage mode can be changed at runtime via the configuration API. Each mode works with both durability settings (durable or async).
3. ACID Properties
ekoDB provides full ACID — Atomicity, Consistency, Isolation, and Durability. Single operations and multi-operation transactions are atomic and durable, and isolation between concurrent transactions is enforced with a configurable level (up to Serializable). The per-property status is below; the Transactions page is the precise reference.
What is ACID?
ACID stands for Atomicity, Consistency, Isolation, and Durability — the four properties of reliable database transactions:
- Atomicity: Operations either complete fully or not at all. On failure, changes are rolled back.
- Consistency: Data moves from one valid state to another; schema constraints and validation are enforced.
- Isolation: Concurrent transactions don't observe each other's in-progress writes.
- Durability: Once committed, data survives a crash. Write-Ahead Logging (WAL) guarantees it.
How ekoDB implements ACID today
- Atomicity ✅ — Single operations are atomic. Multi-operation work (the transaction API and transactional stored functions) is buffered: each statement stages into the transaction and the whole set applies atomically at commit. A failure or rollback discards the staged writes — nothing is partially applied.
- Consistency ✅ — 16 field types and constraint validation (required, unique, min/max, enum, regex, default, null handling) enforce data integrity when a schema is configured.
- Durability ✅ — Write-Ahead Logging with configurable durability modes. In durable mode (the default), a write is fsynced to disk before it is acknowledged, and a failed durable write fails-stop — it is never reported as committed.
- Isolation ✅ — Enforced by optimistic concurrency over per-record version stamps (MVCC). A transaction's uncommitted writes are invisible to others (no dirty reads) and visible to its own reads that carry the transaction id (read-your-writes); at commit ekoDB validates that the records the transaction read or wrote are unchanged and otherwise rejects the commit as a retryable conflict — nothing is applied. The level is per-transaction configurable up to
Serializable, withReadUncommittedas the zero-cost default fast path. No locks are held across statements. This applies to both the transaction API and transactional stored functions.
Transactions
ekoDB supports multi-document transactions with:
- Atomic, all-or-nothing commit with automatic rollback on error
- Savepoints for partial rollback within a transaction
- A configurable, enforced isolation level (up to Serializable) per transaction
- An audit trail for direct writes and for the writes a stored Function makes
For usage and the precise semantics of each isolation level, see the Transactions page.
4. Performance
4.1 Write Performance
Write throughput depends on the durability mode selected. In durable mode, ekoDB leads all tested competitors on write-heavy and mixed YCSB workloads with equivalent persistence guarantees; on pure read-only, PostgreSQL and ekoDB trade the lead. See Performance Benchmarks for the current run. In non-durable mode, throughput increases further for workloads where crash recovery is not critical.
Dual-Node Strategy: Deploy a primary node in non-durable mode and a secondary node in durable mode (via Ripple replication) to achieve both high performance and durability.
4.2 Read Performance
- Indexed Lookups: Fast hash and B-tree index lookups
- Point Queries: Sub-millisecond latency
- Range Queries: Efficient range scans via B-tree indexes
- Full-Text Search: Fast term-based retrieval
- Vector Search: Efficient nearest neighbor search
4.3 Memory Efficiency
- Base Memory: Low memory footprint optimized for efficiency
- Compression: Significant space savings with configurable compression
- Adaptive Allocation: 1%-80% of available RAM
- Automatic Eviction: Intelligent memory management
5. Indexing
5.1 Index Types
ekoDB implements multiple index types optimized for different query patterns:
Hash Indexes (Default)
- Use Case:
WHERE field = value— fast equality lookups - Automatic: Created for frequently queried fields
B-Tree Indexes
- Use Case:
WHERE field > value, sorting, range scans - Features: Supports
<,>,<=,>=,BETWEEN
Inverted Indexes
- Use Case: Full-text search
- Features: Stemming, fuzzy matching, tokenization
Vector Indexes
- Use Case: Semantic similarity search, embeddings, AI/ML workloads
- Metrics: Cosine similarity, Euclidean distance, dot product
- Search Modes: Approximate nearest neighbor and exact search
5.2 Index Management
- Automatic Creation: Indexes created based on query patterns
- Automatic Maintenance: Updated on insert/update/delete
- Concurrent Access: Thread-safe operations
- Memory Efficient: Automatic memory management and eviction
6. Concurrency & Isolation
6.1 Concurrency Control
ekoDB uses a lock-free concurrent in-memory store (sharded maps):
- Concurrent reads: Many readers access data simultaneously without blocking
- Per-key write atomicity: A single record write is applied atomically — never seen half-applied
- Cross-collection independence: Operations on different collections don't block each other
6.2 Isolation
Isolation between concurrent transactions is enforced by optimistic concurrency over per-record version stamps (MVCC). A transaction buffers its writes and applies them atomically at commit, so its uncommitted writes are invisible to other transactions (no dirty reads) and visible only to its own reads that carry the transaction id (read-your-writes). At commit, ekoDB validates that the records the transaction read or wrote have not been changed under it by another committed transaction; if they have, the commit is rejected as a retryable conflict and nothing is applied. No locks are held across statements — conflicts surface at commit rather than blocking.
The level is per-transaction configurable and selects how much the commit validates:
ReadUncommitted— no validation (last-writer-wins); the zero-cost default fast path.ReadCommitted— reject the commit on a write-write conflict (lost-update prevention).RepeatableRead— additionally reject on a read-set change (prevents non-repeatable reads / read skew).Serializable— additionally reject on a collection-membership change (prevents phantoms / write skew; serializable history).
The default level is configurable at runtime (default_isolation_level), and direct (non-transactional) writes bump the same per-record version, so they are coherent with concurrent transactions by construction. The same enforced model backs both the transaction API and transactional stored functions.
7. Durability & Recovery
7.1 Write-Ahead Logging (WAL)
All writes are recorded to a Write-Ahead Log before execution. The durability mode controls whether each WAL entry is fsynced before acknowledging the client (durable) or batched asynchronously (non-durable).
WAL Management:
- Automatic rotation and compaction
- Manual rotation available
- Automatic cleanup after replication
7.2 Recovery Process
ekoDB performs automatic crash recovery. The system validates data integrity and restores the database to its last consistent state. Recovery time depends on data volume and system resources.
8. Search Capabilities
Built on the index types described in Section 5, ekoDB exposes three search modes through a unified query API:
8.1 Full-Text Search
- Field Weighting: Prioritize specific fields in relevance scoring
- Minimum Score: Filter results by relevance threshold
- Fuzzy Matching: Typo tolerance via Levenshtein distance
8.2 Vector Search
- Embedding Support: 384, 768, 1536 dimensions (configurable)
- Metadata Filtering: Combine vector similarity with field filters
- Top-K Results: Efficient nearest-neighbor selection
8.3 Hybrid Search
Combine full-text and vector search in a single query — keyword matching for precision, semantic similarity for recall, with unified scoring and ranking.
9. Distributed Architecture
9.1 Ripple System
ekoDB's distributed architecture uses the Ripple system for real-time data propagation and horizontal scaling:
┌─────────────────────────────────────────────────┐
│ Regional Cluster │
│ ┌─────────────────────────────────────────┐ │
│ │ Instance Groups │ │
│ │ ┌──────────┐ ┌──────────┐ │ │
│ │ │ Node 1 │ │ Node 2 │ ... │ │
│ │ │ (Primary)│ │(Secondary)│ │ │
│ │ └──────────┘ └──────────┘ │ │
│ └─────────────────────────────────────────┘ │
└─────────────────────────────────────────────────┘
↕ Ripple
┌─────────────────────────────────────────────────┐
│ Multi-Tenant Single Nodes │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Tenant A │ │ Tenant B │ │ Tenant C │ │
│ └──────────┘ └──────────┘ └──────────┘ │
└─────────────────────────────────────────────────┘
Core Features:
- Real-Time Propagation: Operations replicate immediately as they occur
- Cross-Database Propagation: Replicate data across ekoDB instances
- Horizontal Scaling: Add nodes for increased read capacity, and for write capacity when writes are partitioned by node
- Regional Distribution: Deploy across geographic regions for low-latency access
- Failover by routing: Ripples does not promote a node when another fails; route traffic with an external load balancer and health check
- Loop Prevention: Automatic deduplication prevents infinite operation loops in multi-node deployments
- Configurable Modes: Send-only, receive-only, bidirectional, or isolated nodes
Real-World Use Cases:
Geographic Distribution (Multi-Region) Deploy primary nodes in US, EU, and Asia with cross-region ripples. Users read from their nearest region for low latency while writes propagate to the other regions (eventual consistency). Partition writes by region so the same record is not written in two places.
Read Scaling (Analytics) Configure a primary write node in durable mode sending ripples to multiple read replicas in non-durable mode. Production traffic doesn't slow down while replicas handle heavy reporting queries.
High Availability (Active-Active) Two primary nodes in bidirectional mode accept writes simultaneously, with automatic loop prevention. There is no conflict resolution: a received write is applied as it arrives, so two nodes writing the same record concurrently diverge. Active-active is safe when writes are partitioned by node. An external load balancer with a health check routes traffic away from a failed node; Ripples does not promote nodes itself.
Data Pipelines (IoT) Dedicated ingestion nodes in non-durable mode propagate to storage nodes in durable mode and processing nodes for real-time analytics. Each layer scales independently.
Development/Staging Production primary sends ripples to staging replica for realistic testing. Test writes in staging don't propagate back to production.
See Ripples - Data Propagation documentation for comprehensive architecture guides and configuration examples
9.2 Replication
Ripples replicates between ekoDB instances in two modes: Operations mode propagates each insert, update and delete in real time, and WAL mode ships committed WAL entries to replicas on an interval. Replication to other databases is on the roadmap.
- Asynchronous Replication: Non-blocking writes
- Configurable Targets: Replicate to multiple ekoDB peers
- Selective Replication: Configure which nodes receive which operations
- No Conflict Resolution: Writes are applied in arrival order, so concurrent writes to the same record on two nodes diverge; partition writes by node for active-active
- Seeding and Backups: New nodes are seeded from a disk snapshot by the managed platform, and Ripples keeps them current
10. Functions
ekoDB's Functions system is a server-side execution engine for composable business logic. A single Function call can query data, transform results, invoke AI models, and call external APIs — all in one request, with no additional network round-trips.
10.1 Composable Server-Side Logic
Functions are JSON-defined, parameterized, versioned, and callable from any client library or the REST API. Each Function contains one or more operations (Query, Insert, Update, Chat, Embed, HttpRequest, and more) that execute sequentially with results flowing between steps. Functions compose freely: a Function can call other Functions via CallFunction, enabling modular workflows without duplicating logic across clients.
Built-in conditional execution (If), iteration (ForEach), and error handling give Functions the control flow needed for real business logic — not just simple queries.
10.2 Caching & Stale-While-Revalidate
Functions integrate naturally with the stale-while-revalidate (SWR) pattern. Cached Function results are served instantly while fresh data is computed in the background. This turns expensive multi-step operations — dashboard summaries, analytics aggregations, enriched user profiles — into instant responses with automatic freshness. For workloads that don't change on every request, SWR eliminates perceived latency entirely.
10.3 Graph Traversal with Vectors
By combining vector search with conditional logic and Function composition, you can build graph-like traversals entirely within ekoDB. Use vector similarity to discover related nodes, chain Functions to walk relationships, and apply conditional branching to shape the traversal — all server-side, in a single call. This enables recommendation engines, knowledge graphs, and relationship discovery without a separate graph database.
10.4 AI Integration
Functions natively support Chat (LLM completions) and Embed (vector generation) operations alongside standard database operations. Build complete RAG pipelines, content moderation workflows, automated summarization, or any AI-augmented logic — without leaving the database layer or adding external orchestration.
10.5 Application Endpoints and Agent Tools
A Function is both an application endpoint and an agent tool. Applications call it with POST /api/functions/{label} or callFunction in any client library, or through a schedule, a signed webhook, or a custom route. AI agents run the same Function with call_function, and an admin key's agent can also find it with list_functions and inspect it with get_function, so there is no separate tool definition to write or keep in sync.
Defining a Function needs an admin key. These checks are enforced in the default enforce mode; on an instance running in shadow mode a refused call grant, step permission or run identity is recorded as access_would_deny and allowed to proceed, while admin-only routes and request validation are enforced in both modes. Calling one needs a call grant: an admin key calls every Function, and any other key calls only the Functions its grants cover by label, by label prefix or with *. A Function runs as an identity, its caller by default or its recorded author, and every step is checked against that identity's collection, field and key-value grants. HttpRequest, SWR and EmailSend need an admin identity; Chat and Embed have no grant of their own and send data to model providers for any key that may call the function. An agent's call runs for the key behind its session and is also limited by the session's collection scope and tool configuration. Schedules and webhook receivers call a Function as the key that created them, and the Function then runs as its own run_as identity. Every write a Function makes adds an audit entry that names the identity the steps ran as, and steps cannot write the audit collection.
For a walkthrough, see Functions. For detailed architecture, operation types, and code examples, see Functions Architecture.
11. Security
11.1 Network Security
HTTPS/WSS Only: Unlike traditional databases that use direct TCP connections, applications reach ekoDB exclusively over HTTPS (REST and Server-Sent Events) and WSS (Secure WebSocket).
Benefits:
- No direct TCP exposure
- Built-in encryption (TLS/SSL)
- Standard web protocols
- Firewall friendly (port 443)
- Certificate-based security
- Protection against man-in-the-middle attacks
11.2 Encryption
At Rest:
- AES-256-GCM encryption for all stored data
- Volume-level encryption provided by ekoDB managed infrastructure
In Transit:
- TLS/SSL for all network communication
- Certificate validation
- Perfect forward secrecy
11.3 Authentication
- JWT Tokens: Industry-standard authentication
- API Keys: Simple authentication for services
- Role-Based Access: Collection-level and field-level permissions
- Token Expiration: Configurable TTL
12. Use Cases
12.1 AI Agents & Workflows
- Functions as Tools: Agents call your stored Functions by name, under the same permissions as your app
- Vector Search: Store and query embeddings
- Chat History: Built-in chat session management
- Context Management: Efficient retrieval of relevant context
- Real-Time Updates: WebSocket for live agent interactions
12.2 Real-Time Analytics
- High Throughput: High-speed ingestion for real-time analytics
- In-Memory Processing: Sub-millisecond queries
- Time-Series Data: Efficient storage and retrieval
- Aggregations: Fast analytical queries
12.3 IoT Data Processing
- Adaptive Scaling: Runs on resource-constrained devices
- Edge Computing: Deploy close to data sources
- Efficient Storage: Compression reduces disk usage
- Batch Operations: Handle bursts of sensor data
12.4 Session Management
- TTL Support: Automatic session expiration
- Fast Lookups: O(1) key-value operations
- High Concurrency: Handle thousands of sessions
- Persistence: Optional durability for sessions
12.5 Content Delivery
- Distributed Caching: Ripple for multi-region deployment
- Fast Reads: In-memory performance
- Compression: Reduce bandwidth usage
- Real-Time Updates: WebSocket for live content
13. Getting Started
13.1 Quick Start
# Install client library
npm install @ekodb/ekodb-client
# Connect to ekoDB
import { EkoDBClient } from "@ekodb/ekodb-client";
const client = new EkoDBClient({
baseURL: "https://my-first-db.development.google.ekodb.net",
apiKey: "your-api-key"
});
await client.init();
// Insert a document
await client.insert("users", {
name: "John Doe",
email: "john@example.com"
});
// Query documents using ekoDB query builder
const query = {
filter: {
type: "Condition",
content: {
field: "age",
operator: "Gt",
value: 25
}
}
};
const users = await client.find("users", query);
13.2 Resources
- Homepage: https://ekodb.io
- Documentation: https://docs.ekodb.io
- Management Console: https://app.ekodb.io
- Support: support@ekodb.io
14. Architecture Deep Dives
For detailed technical documentation on specific subsystems:
- Functions Architecture - Server-side execution, operation types, workflows, and composition patterns
- Transactions Architecture - Atomic, durable, isolated transactions (enforced MVCC isolation), savepoints, and rollback
- Advanced Operations - Client library usage, search capabilities, chat integration, and real-time features
15. About the Author
Sean M. Vazquez is the creator and lead developer of ekoDB. His journey in technology began at age 10, writing HTML, CSS, and JavaScript on an old Compaq computer. Those early years were filled with screen-by-screen adventure games and tinkering with 8-bit and 16-bit consoles (Game Boy, SNES, Sega Genesis), sparking a lifelong passion for building software and the endless wonder of console modding. To this day, he still treasures his N64, playing Mario Kart, Ocarina of Time, 007, and Super Smash Bros with game mods.
As he grew, Sean expanded into C++ and JavaScript, and discovered Linux, a discovery that would shape his approach to systems engineering. He enrolled at Stevens Institute of Technology as a mechanical engineer, but the pull of code was too strong. Remembering the joy of those early programming days, he switched to computer science.
Career Progression:
- Stevens Institute of Technology: B.S. in Computer Science, 2013
- Thomson Reuters: QA Engineer Intern, working on C# tax software where he learned the importance of quality and testing at scale
- UBS: eLearning software implementation and automation, building systems that reached thousands of employees
- TMP Worldwide: Full Stack Engineer focused on front-end development for enterprise recruitment platforms
- Metacake: Full Stack Engineer driving growth engineering and building products from scratch for contract clients
- American Express: Grew from Full Stack Engineer to Senior Engineering Manager and Lead Software Engineer/Architect, leading both product development and internal tooling engineering with a focus on automation
The Origin of ekoDB:
ekoDB began in 2013 as SOLO (Single Object Language Operator), an ambitious vision to create "one API gateway to rule them all." But Sean's vision went further: why just abstract databases when you could make all data universally accessible? The goal became empowering engineers to build their best backends without being constrained by database choices. After nearly a decade as an API gateway, SOLO was rewritten from scratch as ekoDB, a unified database platform that eliminates the complexity of multi-database architectures.
Today, Sean works from a setup that reflects his roots: a Filco tenkeyless keyboard, Raspberry Pis running Arch Linux alongside Debian and Ubuntu, and macOS for daily work. He still has a soft spot for the iPod.
Contact: sean@ekodb.io
Features and specifications are subject to change as ekoDB continues to evolve.