India's developer-first document database.

High-performance document database developed in Rust — with Docker deployment and MongoDB-style APIs for startups and data-intensive apps.

View source on GitHubSelf-hostable · Rust V2 · Developed in India
v2.0.4-pre-alpha
Queryusers.find(...)
users.find({ age: 18 })
Output2 documents matched
$ users.find({ age: 18 })
[
{
name: "Aarav",
age: 18,
plan: "pro",
city: "Bengaluru"
},
{
name: "Meera",
age: 18,
plan: "starter",
city: "Pune"
}
]

Product status

V2 is live and ready.

Pre-alpha tested with real workloads by 10+ developers with 3 detailed feedbacks incorporated.

V2 Pre-alphaLaunched
Engine
Rust
Validation
10+ Devs (3 Real Feedbacks)
Released
16 August 2026
Alpha Launch
23 October 2026
Read the docs

Get Started

Solo Docker Quickstart

Spin up a single local LioranDB instance running directly from Docker. Everything you need to start building.

Installation Command
docker run -d --name liorandb -p 27018:27018 -p 27019:27019 -p 27201:27201 -v ldb-data:/var/lib/liorandb/data liorandb/liorandb:pre-alpha

Build Path

5 / 6
Step 05

Write Your First Query

Connect, insert a document, and execute queries using the TypeScript driver

index.tstypescript
import { LioranDBClient } from "@liorandb/driver";
type User = {
_id?: string;
email: string;
active: boolean;
age: number;
};
const password = encodeURIComponent("Q7m!Z2x@L9p#R4vK");
const uri = `liorandb://admin:${password}@127.0.0.1:27018/default`;
const client = await LioranDBClient.connect(uri);
try {
const db = client.db("default");
const users = db.collection<User>("users");
const insertResult = await users.insertOne({
email: "ada@example.com",
active: true,
age: 31,
});
const user = await users.findOne({ email: "ada@example.com" });
const activeUsers = await users.find({ active: true }).limit(10).toArray();
console.log({
insertedId: insertResult.insertedId,
user,
activeCount: activeUsers.length,
});
} finally {
await client.close();
}
output.jsonjson
{
"insertedId": "01K2EXAMPLE",
"user": {
"_id": "01K2EXAMPLE",
"email": "ada@example.com",
"active": true,
"age": 31
},
"activeCount": 1
}
5 / 6

Developer API

Build with the TypeScript driver.

Connect, query, index, and aggregate with familiar MongoDB-style operations. gRPC and REST APIs are also available.

Operations

TypeScript SDK Example

Connect Operation

query.ts
import { LioranDBClient } from "@liorandb/driver";
const client = await LioranDBClient.connect(
"liorandb://admin:password@127.0.0.1:27018/default"
);
response.json200 OK
// Connected successfully
Client ready to use
Pre-alpha Launched

LioranDB V2 is built in Rust. Now you can code it.

V2 is a high-performance storage engine designed for larger datasets, predictable latency, and transactional workloads. Local Docker pre-alpha is available for developer evaluation and benchmarking, while production workloads are reviewed and managed via our Founder Program. Alpha launch coming on 23 October 2026.

Rust enginePre-alpha • 16 August 2026Managed Hosting Available

Architecture direction

ApplicationsClient requests
LioranDB Query LayerDocument API
Transactions + MVCCSnapshot isolation
Primary B+ TreePrimary pages
WAL + CheckpointsDurability layer
Page CacheHot reads
Persistent StorageOn-disk state
Secondary Index LSM
Text Inverted Index
Compaction
Recovery
Metrics
Encryption

V2 focus

Rust storage engine

V2 focus

MVCC transactions

V2 focus

WAL and recovery

V2 focus

B+ tree primary storage

V2 focus

LSM secondary indexes

V2 focus

Inverted text search

Internal Benchmarking

Built under pressure, not inside a toy demo.

Development testing has reached datasets approaching 100 million documents, with sustained write throughput of 23-25K writes per second and 35K combined operations per second in mixed workloads.

Throughput & Latency Waveform

Internal Stress Benchmarks

Pre-alpha Test Run

Writes/sec

25,140

Reads/sec

34,987

p50 latency

4.3ms

p99 latency

31.7ms

Dataset size

100M docs

Index health

98.4%

Hardware

  • Intel Core Ultra 7 (14th Generation)
  • 16 Physical Cores
  • 24 GB DDR5 @ 5600 MT/s
  • NVMe PCIe SSD

Configuration

  • Nodes: 4
  • Partitions: 8
  • Threads: 32
  • Batch: 256

Write Performance

23K to 25K writes/sec

Sustained write throughput across millions of documents with stable WAL group commit behavior.

Recovery & Durability

Crash Recovery

WAL replay, metadata consistency, and duplicate prevention validated through repeated crash cycles.

Features Tested

Secondary Indexes
Full-Text Search
Write-Ahead Log (WAL)
MVCC
Parallel Read & Write Execution

Write Performance Logs

23K-25K writes/sec with stable WAL group commit

Read Performance Logs

Low millisecond latency with high parallel throughput

Mixed Workload (Soak Test)

~10K writes/sec + ~25K reads/sec = ~35K ops/sec

soak_10m.txt

Crash Recovery Test

WAL replay & durability validation

crash_test_1m_9c.txt

Managed Database Hosting

Transparent pricing for developer infrastructure.

Deploy high-performance LioranDB document database infrastructure with predictable hourly pricing. From ₹1/hr starter testing to ₹8/hr dedicated production servers.

View Full Pricing Page →

How Managed Provisioning Works

STEP 01

Request on Dashboard

Select Starter (₹1/hr) or Dedicated (₹8/hr) on app.liorandb.com.

STEP 02

Workload Review

Our developer team reviews sizing, query patterns, and capacity requirements.

STEP 03

Server Provisioning

Dedicated instance is allocated and activated electronically within 1 to 24 hours.

STEP 04

Connect & Scale

Connect via @liorandb/driver or gRPC/REST endpoints with live throughput metrics.

Starter PlanPay-As-You-Go
₹1/ hour

~₹720 / month (approx. 720 hrs)

Starter plan of our database management service. Ideal for testing, prototypes, and lightweight development instances.

Included with plan:

  • Up to 100,000 documents capacity (100K docs)
  • 3,000 Total Ops/sec (1,000 writes/sec + 2,000 reads/sec)
  • No automated backups included (Starter tier)
  • Starter database management service instance
  • MongoDB-compatible driver & TypeScript SDK
  • gRPC & REST API endpoint access
  • Standard developer community & email support
Starter tier for database management service. No backup coverage.
Get Started for ₹1/hr

Support Schedule

Direct Founder & engineering support is available daily from 6:00 PM to 10:00 PM IST (4 hours nightly), Monday to Friday. Closed on Saturdays and Sundays.

Digital Provisioning

LioranDB provides digital cloud software and database infrastructure. Server instances and connection credentials are provisioned within 1 to 24 hours of approval. No physical shipment.

Subscription & Refund Terms

Billed hourly. Due to immediate allocation of dedicated server compute and storage resources upon provisioning, all payments are covered under our Strict No-Refund Policy. Cancel anytime before renewal.

Developed in India

Indian data deserves Indian infrastructure.

India’s software ecosystem should not depend entirely on infrastructure designed, owned and controlled elsewhere. LioranDB is one step toward a stronger domestic developer platform ecosystem.

Developed in India. Built for the world.

LioranDB is independently developed and is not presented as an official government product or initiative.

Data sovereignty

Give teams the option to keep application data on infrastructure they control, including infrastructure located in India.

Infrastructure independence

Reduce dependency on a small number of foreign database and cloud vendors.

Built for Indian developers

Simple deployment, transparent architecture, founder-led support and pricing designed with Indian startups in mind.

Use Cases

Designed for products that cannot afford database drama.

From internal tools to SaaS backends, the page maps real collection names, query shapes and operating benefits instead of generic market segments.

SaaS platforms

Collections

tenants, billing, feature_flags

{ tenantId: 'acme' }

Keep product data close to the app runtime.

AI applications

Collections

runs, vectors_meta, prompts

{ model: 'custom' }

Log structured model activity without extra services.

CRM systems

Collections

contacts, notes, pipelines

{ ownerId: 'sales-1' }

Iterate on schema as workflows evolve.

Internal developer tools

Collections

jobs, tokens, audit

{ status: 'queued' }

Stay self-hosted for sensitive ops tooling.

APIs and backend services

Collections

sessions, webhooks, caches

{ region: 'IN' }

Ship lightweight persistence directly in Node.js.

Local-first applications

Collections

drafts, sync_queue, profiles

{ device: 'laptop' }

Keep data available close to the user.

Prototypes growing into real products

Collections

leads, events, config

{ stage: 'seed' }

Start simple without throwing away the model later.

Data-intensive startup workloads

Collections

orders, metrics, jobs

{ qty: { $gte: 100 } }

Track the path toward larger Rust-powered workloads.

Developer Experience

Familiar enough to start. Deep enough to grow.

The experience starts with MongoDB-style syntax, stays self-hostable by default, and keeps storage plus performance visible to the engineers running it.

MongoDB-style syntax

const users = db.collection("users");
await users.insertOne({
email: "dev@startup.in",
plan: "pro",
});
const result = await users.find({
plan: "pro",
});
TypeScriptNode.jsJSONRust V2Self-hostedNo lock-in

Self-hostable by default

Run the database inside your Node.js process, keep files under your project, and control deployment instead of handing everything to a managed black box.

TypeScriptNode.jsJSONRust V2Self-hostedNo lock-in

Direct visibility into storage and performance

Inspect directories, snapshots, query paths and benchmark intent without vendor lock-in or hidden service behavior.

TypeScriptNode.jsJSONRust V2Self-hostedNo lock-in

Roadmap

Shipping the database one hard problem at a time.

The roadmap separates what is live, what is being actively built, and what the August 16, 2026 pre-alpha is actually meant to validate.

V2 pre-alpha • Launched

  • Rust storage engine
  • B+ tree and MVCC
  • LSM secondary indexes
  • Text inverted index
  • Crash recovery
  • Docker deployment

V2 Alpha • 23 October 2026

  • Larger dataset testing
  • Driver ecosystem
  • gRPC and REST APIs
  • Managed deployment templates
  • Production hardening
  • Performance optimization

V2 Future

  • Replication and clustering
  • Sharding and partitioning
  • Advanced monitoring
  • Backup and restore
  • Enterprise features
  • Community contributions
Swaraj Puppalwar, Founder and CTO of Lioran Group
Swaraj Puppalwar@UltronTheAI

Founder

Swaraj Puppalwar

Founder & CTO, Lioran Group

Swaraj Puppalwar is an 18-year-old full-stack developer, database engineer and founder building developer infrastructure from India. He began programming at 11 and is leading the architecture and development of LioranDB.

“I don't want India to only consume developer infrastructure. I want us to build it.”
RustTypeScriptStorage enginesDatabasesDistributed systemsDeveloper infrastructure
swaraj@lioran:~/liorandb$ building_indias_infra

Open Development

Watch it being built. Break it before production does.

LioranDB is being developed in the open with feedback from backend engineers, founders and database enthusiasts.

FAQ

Straight answers for evaluating the product.

The page keeps the line between V1, V2, development targets and public availability explicit.

LioranDB V2 is a developer-first document database developed in India. It features a high-performance Rust storage engine launched as pre-alpha on 16 August 2026, with the Alpha release coming on 23 October 2026.

Now you can code it. Pre-alpha is live.

Get started with the Docker Quickstart. Read the docs. Join the community helping shape the production release.

From India to the global developer community.

$ npm install @liorandb/driver
✓ package installed
$ liorandb start
✓ database ready