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.
users.find({ age: 18 })$ 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.
- Engine
- Rust
- Validation
- 10+ Devs (3 Real Feedbacks)
- Released
- 16 August 2026
- Alpha Launch
- 23 October 2026
Get Started
Solo Docker Quickstart
Spin up a single local LioranDB instance running directly from Docker. Everything you need to start building.
docker run -d --name liorandb -p 27018:27018 -p 27019:27019 -p 27201:27201 -v ldb-data:/var/lib/liorandb/data liorandb/liorandb:pre-alphaBuild Path
5 / 6Write Your First Query
Connect, insert a document, and execute queries using the TypeScript driver
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();}{ "insertedId": "01K2EXAMPLE", "user": { "_id": "01K2EXAMPLE", "email": "ada@example.com", "active": true, "age": 31 }, "activeCount": 1}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
import { LioranDBClient } from "@liorandb/driver";const client = await LioranDBClient.connect( "liorandb://admin:password@127.0.0.1:27018/default");// Connected successfullyClient ready to useLioranDB 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.
Architecture direction
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
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
Write Performance Logs
23K-25K writes/sec with stable WAL group commit
Read Performance Logs
Low millisecond latency with high parallel throughput
Managed Database Hosting
Transparent pricing for developer infrastructure.
Deploy high-performance LioranDB document database infrastructure with guaranteed throughput, automated daily backups, and direct founder engineering support.
How Managed Provisioning Works
Request on Dashboard
Submit your database request with target workloads on app.liorandb.com.
Workload Review
Our developer team reviews sizing, query patterns, and capacity requirements.
Server Provisioning
Dedicated instance is allocated and activated via secure monthly subscription checkout.
Connect & Scale
Connect via @liorandb/driver or gRPC/REST endpoints with automated daily backups.
Fully managed, high-performance LioranDB instance for modern SaaS, APIs, and production startup workloads.
Included with plan:
- 45,000 Ops/sec throughput (10k write ops/sec + 35k read ops/sec)
- Under 1 Million documents capacity (< 1M docs)
- Automated daily snapshot backups
- Direct Founder & Core Engineering support
- Basic feature & optimization requests
- Dedicated single-node cloud provisioning
- MongoDB-compatible driver & gRPC/REST APIs
- Support window: 6:00 PM – 10:00 PM IST (Mon–Fri)
Custom multi-node cluster, high-throughput tuning, and enterprise SLAs for data-intensive systems.
Included with plan:
- High-throughput scaling (> 45k ops/sec custom limits)
- Multi-million document storage (> 1M docs)
- Custom backup intervals & Point-in-time recovery (PITR)
- Priority founder SLA & dedicated engineering assistance
- Custom query operators, driver tweaks & schema consulting
- Multi-node clustering, replication & failover setup
- Dedicated VPC / private peering deployment
- Extended priority incident coverage
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
Subscriptions are billed monthly. 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 the next billing cycle.
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
Keep product data close to the app runtime.
AI applications
Collections
runs, vectors_meta, prompts
Log structured model activity without extra services.
CRM systems
Collections
contacts, notes, pipelines
Iterate on schema as workflows evolve.
Internal developer tools
Collections
jobs, tokens, audit
Stay self-hosted for sensitive ops tooling.
APIs and backend services
Collections
sessions, webhooks, caches
Ship lightweight persistence directly in Node.js.
Local-first applications
Collections
drafts, sync_queue, profiles
Keep data available close to the user.
Prototypes growing into real products
Collections
leads, events, config
Start simple without throwing away the model later.
Data-intensive startup workloads
Collections
orders, metrics, jobs
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",});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.
Direct visibility into storage and performance
Inspect directories, snapshots, query paths and benchmark intent without vendor lock-in or hidden service behavior.
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
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.”
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.
GitHub Activity Panel
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