bump to v0.29.3

fix auth-required not sending immediate challenge, benchmark leak
add dgraph backend to benchmark suite with safe type assertions for multi-backend support
2025-11-18 18:22:39 +00:00 · 2025-11-18 18:21:11 +00:00 · 2025-11-17 16:52:38 +00:00 · 2025-11-17 08:19:44 +00:00
53 changed files with 6591 additions and 291 deletions
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@@ -83,7 +83,18 @@
      "Bash(ORLY_LOG_LEVEL=debug timeout 60 ./orly:*)",
      "Bash(ORLY_LOG_LEVEL=debug timeout 30 ./orly:*)",
      "Bash(killall:*)",
-      "Bash(kill:*)"
+      "Bash(kill:*)",
+      "Bash(gh repo list:*)",
+      "Bash(gh auth:*)",
+      "Bash(/tmp/backup-github-repos.sh)",
+      "Bash(./benchmark:*)",
+      "Bash(env)",
+      "Bash(./run-badger-benchmark.sh:*)",
+      "Bash(./update-github-vpn.sh:*)",
+      "Bash(dmesg:*)",
+      "Bash(export:*)",
+      "Bash(timeout 60 /tmp/benchmark-fixed:*)",
+      "Bash(/tmp/test-auth-event.sh)"
    ],
    "deny": [],
    "ask": []
--- a/.gitignore
+++ b/.gitignore
@@ -136,3 +136,19 @@ build/orly-*
 build/libsecp256k1-*
 build/SHA256SUMS-*
 Dockerfile
+/cmd/benchmark/reports/run_20251116_172629/aggregate_report.txt
+/cmd/benchmark/reports/run_20251116_172629/next-orly_results.txt
+/cmd/benchmark/reports/run_20251116_173450/aggregate_report.txt
+/cmd/benchmark/reports/run_20251116_173450/next-orly_results.txt
+/cmd/benchmark/reports/run_20251116_173846/aggregate_report.txt
+/cmd/benchmark/reports/run_20251116_173846/next-orly_results.txt
+/cmd/benchmark/reports/run_20251116_174246/aggregate_report.txt
+/cmd/benchmark/reports/run_20251116_174246/next-orly_results.txt
+/cmd/benchmark/reports/run_20251116_182250/aggregate_report.txt
+/cmd/benchmark/reports/run_20251116_182250/next-orly_results.txt
+/cmd/benchmark/reports/run_20251116_203720/aggregate_report.txt
+/cmd/benchmark/reports/run_20251116_203720/next-orly_results.txt
+/cmd/benchmark/reports/run_20251116_225648/aggregate_report.txt
+/cmd/benchmark/reports/run_20251116_225648/next-orly_results.txt
+/cmd/benchmark/reports/run_20251116_233547/aggregate_report.txt
+/cmd/benchmark/reports/run_20251116_233547/next-orly_results.txt
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -8,11 +8,11 @@ ORLY is a high-performance Nostr relay written in Go, designed for personal rela

 **Key Technologies:**
 - **Language**: Go 1.25.3+
- **Database**: Badger v4 (embedded key-value store)
+- **Database**: Badger v4 (embedded key-value store) or DGraph (distributed graph database)
 - **Cryptography**: Custom p8k library using purego for secp256k1 operations (no CGO)
 - **Web UI**: Svelte frontend embedded in the binary
 - **WebSocket**: gorilla/websocket for Nostr protocol
- **Performance**: SIMD-accelerated SHA256 and hex encoding
+- **Performance**: SIMD-accelerated SHA256 and hex encoding, query result caching with zstd compression

 ## Build Commands

@@ -41,8 +41,8 @@ go build -o orly
 ### Development Mode (Web UI Hot Reload)
 ```bash
 # Terminal 1: Start relay with dev proxy
-export ORLY_WEB_DISABLE_EMBEDDED=true
-export ORLY_WEB_DEV_PROXY_URL=localhost:5000
+export ORLY_WEB_DISABLE=true
+export ORLY_WEB_DEV_PROXY_URL=http://localhost:5173
 ./orly &

 # Terminal 2: Start dev server
@@ -89,11 +89,18 @@ go run cmd/relay-tester/main.go -url ws://localhost:3334 -test "Basic Event"

 ### Benchmarking
 ```bash
-# Run benchmarks in specific package
+# Run Go benchmarks in specific package
 go test -bench=. -benchmem ./pkg/database

 # Crypto benchmarks
 cd pkg/crypto/p8k && make bench
+
+# Run full relay benchmark suite
+cd cmd/benchmark
+go run main.go -data-dir /tmp/bench-db -events 10000 -workers 4
+
+# Benchmark reports are saved to cmd/benchmark/reports/
+# The benchmark tool tests event storage, queries, and subscription performance
 ```

 ## Running the Relay
@@ -131,6 +138,18 @@ export ORLY_SPROCKET_ENABLED=true

 # Enable policy system
 export ORLY_POLICY_ENABLED=true
+
+# Database backend selection (badger or dgraph)
+export ORLY_DB_TYPE=badger
+export ORLY_DGRAPH_URL=localhost:9080  # Only for dgraph backend
+
+# Query cache configuration (improves REQ response times)
+export ORLY_QUERY_CACHE_SIZE_MB=512      # Default: 512MB
+export ORLY_QUERY_CACHE_MAX_AGE=5m       # Cache expiry time
+
+# Database cache tuning (for Badger backend)
+export ORLY_DB_BLOCK_CACHE_MB=512        # Block cache size
+export ORLY_DB_INDEX_CACHE_MB=256        # Index cache size
 ```

 ## Code Architecture
@@ -155,10 +174,12 @@ export ORLY_POLICY_ENABLED=true
 - `web.go` - Embedded web UI serving and dev proxy
 - `config/` - Environment variable configuration using go-simpler.org/env

-**`pkg/database/`** - Badger-based event storage
- `database.go` - Database initialization with cache tuning
+**`pkg/database/`** - Database abstraction layer with multiple backend support
+- `interface.go` - Database interface definition for pluggable backends
+- `factory.go` - Database backend selection (Badger or DGraph)
+- `database.go` - Badger implementation with cache tuning and query cache
 - `save-event.go` - Event storage with index updates
- `query-events.go` - Main query execution engine
+- `query-events.go` - Main query execution engine with filter normalization
 - `query-for-*.go` - Specialized query builders for different filter patterns
 - `indexes/` - Index key construction for efficient lookups
 - `export.go` / `import.go` - Event export/import in JSONL format
@@ -238,10 +259,19 @@ export ORLY_POLICY_ENABLED=true
 - This avoids CGO complexity while maintaining C library performance
 - `libsecp256k1.so` must be in `LD_LIBRARY_PATH` or same directory as binary

+**Database Backend Selection:**
+- Supports multiple backends via `ORLY_DB_TYPE` environment variable
+- **Badger** (default): Embedded key-value store with custom indexing, ideal for single-instance deployments
+- **DGraph**: Distributed graph database for larger, multi-node deployments
+- Backend selected via factory pattern in `pkg/database/factory.go`
+- All backends implement the same `Database` interface defined in `pkg/database/interface.go`
+
 **Database Query Pattern:**
 - Filters are analyzed in `get-indexes-from-filter.go` to determine optimal query strategy
+- Filters are normalized before cache lookup, ensuring identical queries with different field ordering hit the cache
 - Different query builders (`query-for-kinds.go`, `query-for-authors.go`, etc.) handle specific filter patterns
 - All queries return event serials (uint64) for efficient joining
+- Query results cached with zstd level 9 compression (configurable size and TTL)
 - Final events fetched via `fetch-events-by-serials.go`

 **WebSocket Message Flow:**
@@ -272,7 +302,7 @@ export ORLY_POLICY_ENABLED=true

 ### Making Changes to Web UI
 1. Edit files in `app/web/src/`
-2. For hot reload: `cd app/web && bun run dev` (with `ORLY_WEB_DISABLE_EMBEDDED=true`)
+2. For hot reload: `cd app/web && bun run dev` (with `ORLY_WEB_DISABLE=true` and `ORLY_WEB_DEV_PROXY_URL=http://localhost:5173`)
 3. For production build: `./scripts/update-embedded-web.sh`

 ### Adding New Nostr Protocol Handlers
@@ -377,12 +407,42 @@ sudo journalctl -u orly -f

 ## Performance Considerations

- **Database Caching**: Tune `ORLY_DB_BLOCK_CACHE_MB` and `ORLY_DB_INDEX_CACHE_MB` for workload
- **Query Optimization**: Add indexes for common filter patterns
+- **Query Cache**: 512MB query result cache (configurable via `ORLY_QUERY_CACHE_SIZE_MB`) with zstd level 9 compression reduces database load for repeated queries
+- **Filter Normalization**: Filters are normalized before cache lookup, so identical queries with different field ordering produce cache hits
+- **Database Caching**: Tune `ORLY_DB_BLOCK_CACHE_MB` and `ORLY_DB_INDEX_CACHE_MB` for workload (Badger backend only)
+- **Query Optimization**: Add indexes for common filter patterns; multiple specialized query builders optimize different filter combinations
+- **Batch Operations**: ID lookups and event fetching use batch operations via `GetSerialsByIds` and `FetchEventsBySerials`
 - **Memory Pooling**: Use buffer pools in encoders (see `pkg/encoders/event/`)
- **SIMD Operations**: Leverage minio/sha256-simd and templexxx/xhex
+- **SIMD Operations**: Leverage minio/sha256-simd and templexxx/xhex for cryptographic operations
 - **Goroutine Management**: Each WebSocket connection runs in its own goroutine

+## Recent Optimizations
+
+ORLY has received several significant performance improvements in recent updates:
+
+### Query Cache System (Latest)
+- 512MB query result cache with zstd level 9 compression
+- Filter normalization ensures cache hits regardless of filter field ordering
+- Configurable size (`ORLY_QUERY_CACHE_SIZE_MB`) and TTL (`ORLY_QUERY_CACHE_MAX_AGE`)
+- Dramatically reduces database load for repeated queries (common in Nostr clients)
+- Cache key includes normalized filter representation for optimal hit rate
+
+### Badger Cache Tuning
+- Optimized block cache (default 512MB, tune via `ORLY_DB_BLOCK_CACHE_MB`)
+- Optimized index cache (default 256MB, tune via `ORLY_DB_INDEX_CACHE_MB`)
+- Resulted in 10-15% improvement in most benchmark scenarios
+- See git history for cache tuning evolution
+
+### Query Execution Improvements
+- Multiple specialized query builders for different filter patterns:
+  - `query-for-kinds.go` - Kind-based queries
+  - `query-for-authors.go` - Author-based queries
+  - `query-for-tags.go` - Tag-based queries
+  - Combination builders for `kinds+authors`, `kinds+tags`, `kinds+authors+tags`
+- Batch operations for ID lookups via `GetSerialsByIds`
+- Serial-based event fetching for efficiency
+- Filter analysis in `get-indexes-from-filter.go` selects optimal strategy
+
 ## Release Process

 1. Update version in `pkg/version/version` file (e.g., v1.2.3)
--- a/app/handle-event.go
+++ b/app/handle-event.go
@@ -253,6 +253,12 @@ func (l *Listener) HandleEvent(msg []byte) (err error) {
 		).Write(l); chk.E(err) {
 			return
 		}
+		// Send AUTH challenge to prompt authentication
+		log.D.F("HandleEvent: sending AUTH challenge to %s", l.remote)
+		if err = authenvelope.NewChallengeWith(l.challenge.Load()).
+			Write(l); chk.E(err) {
+			return
+		}
 		return
 	}

--- a/app/handle-websocket.go
+++ b/app/handle-websocket.go
@@ -118,7 +118,8 @@ whitelist:
 	chal := make([]byte, 32)
 	rand.Read(chal)
 	listener.challenge.Store([]byte(hex.Enc(chal)))
-	if s.Config.ACLMode != "none" {
+	// Send AUTH challenge if ACL mode requires it, or if auth is required/required for writes
+	if s.Config.ACLMode != "none" || s.Config.AuthRequired || s.Config.AuthToWrite {
 		log.D.F("sending AUTH challenge to %s", remote)
 		if err = authenvelope.NewChallengeWith(listener.challenge.Load()).
 			Write(listener); chk.E(err) {
--- a/app/main.go
+++ b/app/main.go
@@ -85,9 +85,9 @@ func Run(
 	// Initialize policy manager
 	l.policyManager = policy.NewWithManager(ctx, cfg.AppName, cfg.PolicyEnabled)

-	// Initialize spider manager based on mode
-	if cfg.SpiderMode != "none" {
-		if l.spiderManager, err = spider.New(ctx, db.(*database.D), l.publishers, cfg.SpiderMode); chk.E(err) {
+	// Initialize spider manager based on mode (only for Badger backend)
+	if badgerDB, ok := db.(*database.D); ok && cfg.SpiderMode != "none" {
+		if l.spiderManager, err = spider.New(ctx, badgerDB, l.publishers, cfg.SpiderMode); chk.E(err) {
 			log.E.F("failed to create spider manager: %v", err)
 		} else {
 			// Set up callbacks for follows mode
@@ -141,67 +141,79 @@ func Run(
 		}
 	}

-	// Initialize relay group manager
-	l.relayGroupMgr = dsync.NewRelayGroupManager(db.(*database.D), cfg.RelayGroupAdmins)
-
-	// Initialize sync manager if relay peers are configured
-	var peers []string
-	if len(cfg.RelayPeers) > 0 {
-		peers = cfg.RelayPeers
-	} else {
-		// Try to get peers from relay group configuration
-		if config, err := l.relayGroupMgr.FindAuthoritativeConfig(ctx); err == nil && config != nil {
-			peers = config.Relays
-			log.I.F("using relay group configuration with %d peers", len(peers))
-		}
+	// Initialize relay group manager (only for Badger backend)
+	if badgerDB, ok := db.(*database.D); ok {
+		l.relayGroupMgr = dsync.NewRelayGroupManager(badgerDB, cfg.RelayGroupAdmins)
+	} else if cfg.SpiderMode != "none" || len(cfg.RelayPeers) > 0 || len(cfg.ClusterAdmins) > 0 {
+		log.I.Ln("spider, sync, and cluster features require Badger backend (currently using alternative backend)")
 	}

-	if len(peers) > 0 {
-		// Get relay identity for node ID
-		sk, err := db.GetOrCreateRelayIdentitySecret()
-		if err != nil {
-			log.E.F("failed to get relay identity for sync: %v", err)
+	// Initialize sync manager if relay peers are configured (only for Badger backend)
+	if badgerDB, ok := db.(*database.D); ok {
+		var peers []string
+		if len(cfg.RelayPeers) > 0 {
+			peers = cfg.RelayPeers
 		} else {
-			nodeID, err := keys.SecretBytesToPubKeyHex(sk)
-			if err != nil {
-				log.E.F("failed to derive pubkey for sync node ID: %v", err)
-			} else {
-				relayURL := cfg.RelayURL
-				if relayURL == "" {
-					relayURL = fmt.Sprintf("http://localhost:%d", cfg.Port)
+			// Try to get peers from relay group configuration
+			if l.relayGroupMgr != nil {
+				if config, err := l.relayGroupMgr.FindAuthoritativeConfig(ctx); err == nil && config != nil {
+					peers = config.Relays
+					log.I.F("using relay group configuration with %d peers", len(peers))
+				}
+			}
+		}
+
+		if len(peers) > 0 {
+			// Get relay identity for node ID
+			sk, err := db.GetOrCreateRelayIdentitySecret()
+			if err != nil {
+				log.E.F("failed to get relay identity for sync: %v", err)
+			} else {
+				nodeID, err := keys.SecretBytesToPubKeyHex(sk)
+				if err != nil {
+					log.E.F("failed to derive pubkey for sync node ID: %v", err)
+				} else {
+					relayURL := cfg.RelayURL
+					if relayURL == "" {
+						relayURL = fmt.Sprintf("http://localhost:%d", cfg.Port)
+					}
+					l.syncManager = dsync.NewManager(ctx, badgerDB, nodeID, relayURL, peers, l.relayGroupMgr, l.policyManager)
+					log.I.F("distributed sync manager initialized with %d peers", len(peers))
 				}
-				l.syncManager = dsync.NewManager(ctx, db.(*database.D), nodeID, relayURL, peers, l.relayGroupMgr, l.policyManager)
-				log.I.F("distributed sync manager initialized with %d peers", len(peers))
 			}
 		}
 	}

-	// Initialize cluster manager for cluster replication
-	var clusterAdminNpubs []string
-	if len(cfg.ClusterAdmins) > 0 {
-		clusterAdminNpubs = cfg.ClusterAdmins
-	} else {
-		// Default to regular admins if no cluster admins specified
-		for _, admin := range cfg.Admins {
-			clusterAdminNpubs = append(clusterAdminNpubs, admin)
+	// Initialize cluster manager for cluster replication (only for Badger backend)
+	if badgerDB, ok := db.(*database.D); ok {
+		var clusterAdminNpubs []string
+		if len(cfg.ClusterAdmins) > 0 {
+			clusterAdminNpubs = cfg.ClusterAdmins
+		} else {
+			// Default to regular admins if no cluster admins specified
+			for _, admin := range cfg.Admins {
+				clusterAdminNpubs = append(clusterAdminNpubs, admin)
+			}
 		}
-	}

-	if len(clusterAdminNpubs) > 0 {
-		l.clusterManager = dsync.NewClusterManager(ctx, db.(*database.D), clusterAdminNpubs, cfg.ClusterPropagatePrivilegedEvents, l.publishers)
-		l.clusterManager.Start()
-		log.I.F("cluster replication manager initialized with %d admin npubs", len(clusterAdminNpubs))
+		if len(clusterAdminNpubs) > 0 {
+			l.clusterManager = dsync.NewClusterManager(ctx, badgerDB, clusterAdminNpubs, cfg.ClusterPropagatePrivilegedEvents, l.publishers)
+			l.clusterManager.Start()
+			log.I.F("cluster replication manager initialized with %d admin npubs", len(clusterAdminNpubs))
+		}
 	}

 	// Initialize the user interface
 	l.UserInterface()

-	// Initialize Blossom blob storage server
-	if l.blossomServer, err = initializeBlossomServer(ctx, cfg, db.(*database.D)); err != nil {
-		log.E.F("failed to initialize blossom server: %v", err)
-		// Continue without blossom server
-	} else if l.blossomServer != nil {
-		log.I.F("blossom blob storage server initialized")
+	// Initialize Blossom blob storage server (only for Badger backend)
+	if badgerDB, ok := db.(*database.D); ok {
+		if l.blossomServer, err = initializeBlossomServer(ctx, cfg, badgerDB); err != nil {
+			log.E.F("failed to initialize blossom server: %v", err)
+			// Continue without blossom server
+		} else if l.blossomServer != nil {
+			log.I.F("blossom blob storage server initialized")
+		}
 	}

 	// Ensure a relay identity secret key exists when subscriptions and NWC are enabled
@@ -237,14 +249,17 @@ func Run(
 		}
 	}

-	if l.paymentProcessor, err = NewPaymentProcessor(ctx, cfg, db.(*database.D)); err != nil {
-		// log.E.F("failed to create payment processor: %v", err)
-		// Continue without payment processor
-	} else {
-		if err = l.paymentProcessor.Start(); err != nil {
-			log.E.F("failed to start payment processor: %v", err)
+	// Initialize payment processor (only for Badger backend)
+	if badgerDB, ok := db.(*database.D); ok {
+		if l.paymentProcessor, err = NewPaymentProcessor(ctx, cfg, badgerDB); err != nil {
+			// log.E.F("failed to create payment processor: %v", err)
+			// Continue without payment processor
 		} else {
-			log.I.F("payment processor started successfully")
+			if err = l.paymentProcessor.Start(); err != nil {
+				log.E.F("failed to start payment processor: %v", err)
+			} else {
+				log.I.F("payment processor started successfully")
+			}
 		}
 	}

--- a/cmd/benchmark/README.md
+++ b/cmd/benchmark/README.md
@@ -2,7 +2,7 @@

 A comprehensive benchmarking system for testing and comparing the performance of multiple Nostr relay implementations, including:

- **next.orly.dev** (this repository) - BadgerDB-based relay
+- **next.orly.dev** (this repository) - Badger and DGraph backend variants
 - **Khatru** - SQLite and Badger variants
 - **Relayer** - Basic example implementation
 - **Strfry** - C++ LMDB-based relay
@@ -91,13 +91,16 @@ ls reports/run_YYYYMMDD_HHMMSS/

 ### Docker Compose Services

-| Service          | Port | Description                               |
-| ---------------- | ---- | ----------------------------------------- |
-| next-orly        | 8001 | This repository's BadgerDB relay          |
-| khatru-sqlite    | 8002 | Khatru with SQLite backend                |
-| khatru-badger    | 8003 | Khatru with Badger backend                |
-| relayer-basic    | 8004 | Basic relayer example                     |
-| strfry           | 8005 | Strfry C++ LMDB relay                     |
+| Service            | Port | Description                               |
+| ------------------ | ---- | ----------------------------------------- |
+| next-orly-badger   | 8001 | This repository's Badger relay            |
+| next-orly-dgraph   | 8007 | This repository's DGraph relay            |
+| dgraph-zero        | 5080 | DGraph cluster coordinator                |
+| dgraph-alpha       | 9080 | DGraph data node                          |
+| khatru-sqlite      | 8002 | Khatru with SQLite backend                |
+| khatru-badger      | 8003 | Khatru with Badger backend                |
+| relayer-basic      | 8004 | Basic relayer example                     |
+| strfry             | 8005 | Strfry C++ LMDB relay                     |
 | nostr-rs-relay   | 8006 | Rust SQLite relay                         |
 | benchmark-runner | -    | Orchestrates tests and aggregates results |

@@ -173,6 +176,39 @@ go build -o benchmark main.go
  -duration=30s
 ```

+## Database Backend Comparison
+
+The benchmark suite includes **next.orly.dev** with two different database backends to compare architectural approaches:
+
+### Badger Backend (next-orly-badger)
+- **Type**: Embedded key-value store
+- **Architecture**: Single-process, no network overhead
+- **Best for**: Personal relays, single-instance deployments
+- **Characteristics**:
+  - Lower latency for single-instance operations
+  - No network round-trips
+  - Simpler deployment
+  - Limited to single-node scaling
+
+### DGraph Backend (next-orly-dgraph)
+- **Type**: Distributed graph database
+- **Architecture**: Client-server with dgraph-zero (coordinator) and dgraph-alpha (data node)
+- **Best for**: Distributed deployments, horizontal scaling
+- **Characteristics**:
+  - Network overhead from gRPC communication
+  - Supports multi-node clustering
+  - Built-in replication and sharding
+  - More complex deployment
+
+### Comparing the Backends
+
+The benchmark results will show:
+- **Latency differences**: Embedded vs. distributed overhead
+- **Throughput trade-offs**: Single-process optimization vs. distributed scalability
+- **Resource usage**: Memory and CPU patterns for different architectures
+
+This comparison helps determine which backend is appropriate for different deployment scenarios.
+
 ## Benchmark Results Interpretation

 ### Peak Throughput Test
--- a/cmd/benchmark/benchmark_adapter.go
+++ b/cmd/benchmark/benchmark_adapter.go
@@ -0,0 +1,574 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"sync"
+	"time"
+
+	"next.orly.dev/pkg/database"
+	"next.orly.dev/pkg/encoders/event"
+	"next.orly.dev/pkg/encoders/filter"
+	"next.orly.dev/pkg/encoders/kind"
+	"next.orly.dev/pkg/encoders/tag"
+	"next.orly.dev/pkg/encoders/timestamp"
+	"next.orly.dev/pkg/interfaces/signer/p8k"
+)
+
+// BenchmarkAdapter adapts a database.Database interface to work with benchmark tests
+type BenchmarkAdapter struct {
+	config  *BenchmarkConfig
+	db      database.Database
+	results []*BenchmarkResult
+	mu      sync.RWMutex
+}
+
+// NewBenchmarkAdapter creates a new benchmark adapter
+func NewBenchmarkAdapter(config *BenchmarkConfig, db database.Database) *BenchmarkAdapter {
+	return &BenchmarkAdapter{
+		config:  config,
+		db:      db,
+		results: make([]*BenchmarkResult, 0),
+	}
+}
+
+// RunPeakThroughputTest runs the peak throughput benchmark
+func (ba *BenchmarkAdapter) RunPeakThroughputTest() {
+	fmt.Println("\n=== Peak Throughput Test ===")
+
+	start := time.Now()
+	var wg sync.WaitGroup
+	var totalEvents int64
+	var errors []error
+	var latencies []time.Duration
+	var mu sync.Mutex
+
+	events := ba.generateEvents(ba.config.NumEvents)
+	eventChan := make(chan *event.E, len(events))
+
+	// Fill event channel
+	for _, ev := range events {
+		eventChan <- ev
+	}
+	close(eventChan)
+
+	// Start workers
+	for i := 0; i < ba.config.ConcurrentWorkers; i++ {
+		wg.Add(1)
+		go func(workerID int) {
+			defer wg.Done()
+
+			ctx := context.Background()
+			for ev := range eventChan {
+				eventStart := time.Now()
+
+				_, err := ba.db.SaveEvent(ctx, ev)
+				latency := time.Since(eventStart)
+
+				mu.Lock()
+				if err != nil {
+					errors = append(errors, err)
+				} else {
+					totalEvents++
+					latencies = append(latencies, latency)
+				}
+				mu.Unlock()
+			}
+		}(i)
+	}
+
+	wg.Wait()
+	duration := time.Since(start)
+
+	// Calculate metrics
+	result := &BenchmarkResult{
+		TestName:          "Peak Throughput",
+		Duration:          duration,
+		TotalEvents:       int(totalEvents),
+		EventsPerSecond:   float64(totalEvents) / duration.Seconds(),
+		ConcurrentWorkers: ba.config.ConcurrentWorkers,
+		MemoryUsed:        getMemUsage(),
+	}
+
+	if len(latencies) > 0 {
+		sort.Slice(latencies, func(i, j int) bool {
+			return latencies[i] < latencies[j]
+		})
+		result.AvgLatency = calculateAverage(latencies)
+		result.P90Latency = latencies[int(float64(len(latencies))*0.90)]
+		result.P95Latency = latencies[int(float64(len(latencies))*0.95)]
+		result.P99Latency = latencies[int(float64(len(latencies))*0.99)]
+
+		bottom10 := latencies[:int(float64(len(latencies))*0.10)]
+		result.Bottom10Avg = calculateAverage(bottom10)
+	}
+
+	result.SuccessRate = float64(totalEvents) / float64(ba.config.NumEvents) * 100
+	if len(errors) > 0 {
+		result.Errors = make([]string, 0, len(errors))
+		for _, err := range errors {
+			result.Errors = append(result.Errors, err.Error())
+		}
+	}
+
+	ba.mu.Lock()
+	ba.results = append(ba.results, result)
+	ba.mu.Unlock()
+
+	ba.printResult(result)
+}
+
+// RunBurstPatternTest runs burst pattern test
+func (ba *BenchmarkAdapter) RunBurstPatternTest() {
+	fmt.Println("\n=== Burst Pattern Test ===")
+
+	start := time.Now()
+	var totalEvents int64
+	var latencies []time.Duration
+	var mu sync.Mutex
+
+	ctx := context.Background()
+	burstSize := 100
+	bursts := ba.config.NumEvents / burstSize
+
+	for i := 0; i < bursts; i++ {
+		// Generate a burst of events
+		events := ba.generateEvents(burstSize)
+
+		var wg sync.WaitGroup
+		for _, ev := range events {
+			wg.Add(1)
+			go func(e *event.E) {
+				defer wg.Done()
+
+				eventStart := time.Now()
+				_, err := ba.db.SaveEvent(ctx, e)
+				latency := time.Since(eventStart)
+
+				mu.Lock()
+				if err == nil {
+					totalEvents++
+					latencies = append(latencies, latency)
+				}
+				mu.Unlock()
+			}(ev)
+		}
+
+		wg.Wait()
+
+		// Short pause between bursts
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	duration := time.Since(start)
+
+	result := &BenchmarkResult{
+		TestName:          "Burst Pattern",
+		Duration:          duration,
+		TotalEvents:       int(totalEvents),
+		EventsPerSecond:   float64(totalEvents) / duration.Seconds(),
+		ConcurrentWorkers: burstSize,
+		MemoryUsed:        getMemUsage(),
+		SuccessRate:       float64(totalEvents) / float64(ba.config.NumEvents) * 100,
+	}
+
+	if len(latencies) > 0 {
+		sort.Slice(latencies, func(i, j int) bool {
+			return latencies[i] < latencies[j]
+		})
+		result.AvgLatency = calculateAverage(latencies)
+		result.P90Latency = latencies[int(float64(len(latencies))*0.90)]
+		result.P95Latency = latencies[int(float64(len(latencies))*0.95)]
+		result.P99Latency = latencies[int(float64(len(latencies))*0.99)]
+
+		bottom10 := latencies[:int(float64(len(latencies))*0.10)]
+		result.Bottom10Avg = calculateAverage(bottom10)
+	}
+
+	ba.mu.Lock()
+	ba.results = append(ba.results, result)
+	ba.mu.Unlock()
+
+	ba.printResult(result)
+}
+
+// RunMixedReadWriteTest runs mixed read/write test
+func (ba *BenchmarkAdapter) RunMixedReadWriteTest() {
+	fmt.Println("\n=== Mixed Read/Write Test ===")
+
+	// First, populate some events
+	fmt.Println("Populating database with initial events...")
+	populateEvents := ba.generateEvents(1000)
+	ctx := context.Background()
+
+	for _, ev := range populateEvents {
+		ba.db.SaveEvent(ctx, ev)
+	}
+
+	start := time.Now()
+	var writeCount, readCount int64
+	var latencies []time.Duration
+	var mu sync.Mutex
+	var wg sync.WaitGroup
+
+	// Start workers doing mixed read/write
+	for i := 0; i < ba.config.ConcurrentWorkers; i++ {
+		wg.Add(1)
+		go func(workerID int) {
+			defer wg.Done()
+
+			events := ba.generateEvents(ba.config.NumEvents / ba.config.ConcurrentWorkers)
+
+			for idx, ev := range events {
+				eventStart := time.Now()
+
+				if idx%3 == 0 {
+					// Read operation
+					f := filter.New()
+					f.Kinds = kind.NewS(kind.TextNote)
+					limit := uint(10)
+					f.Limit = &limit
+					_, _ = ba.db.QueryEvents(ctx, f)
+
+					mu.Lock()
+					readCount++
+					mu.Unlock()
+				} else {
+					// Write operation
+					_, _ = ba.db.SaveEvent(ctx, ev)
+
+					mu.Lock()
+					writeCount++
+					mu.Unlock()
+				}
+
+				latency := time.Since(eventStart)
+				mu.Lock()
+				latencies = append(latencies, latency)
+				mu.Unlock()
+			}
+		}(i)
+	}
+
+	wg.Wait()
+	duration := time.Since(start)
+
+	result := &BenchmarkResult{
+		TestName:          fmt.Sprintf("Mixed R/W (R:%d W:%d)", readCount, writeCount),
+		Duration:          duration,
+		TotalEvents:       int(writeCount + readCount),
+		EventsPerSecond:   float64(writeCount+readCount) / duration.Seconds(),
+		ConcurrentWorkers: ba.config.ConcurrentWorkers,
+		MemoryUsed:        getMemUsage(),
+		SuccessRate:       100.0,
+	}
+
+	if len(latencies) > 0 {
+		sort.Slice(latencies, func(i, j int) bool {
+			return latencies[i] < latencies[j]
+		})
+		result.AvgLatency = calculateAverage(latencies)
+		result.P90Latency = latencies[int(float64(len(latencies))*0.90)]
+		result.P95Latency = latencies[int(float64(len(latencies))*0.95)]
+		result.P99Latency = latencies[int(float64(len(latencies))*0.99)]
+
+		bottom10 := latencies[:int(float64(len(latencies))*0.10)]
+		result.Bottom10Avg = calculateAverage(bottom10)
+	}
+
+	ba.mu.Lock()
+	ba.results = append(ba.results, result)
+	ba.mu.Unlock()
+
+	ba.printResult(result)
+}
+
+// RunQueryTest runs query performance test
+func (ba *BenchmarkAdapter) RunQueryTest() {
+	fmt.Println("\n=== Query Performance Test ===")
+
+	// Populate with test data
+	fmt.Println("Populating database for query tests...")
+	events := ba.generateEvents(5000)
+	ctx := context.Background()
+
+	for _, ev := range events {
+		ba.db.SaveEvent(ctx, ev)
+	}
+
+	start := time.Now()
+	var queryCount int64
+	var latencies []time.Duration
+	var mu sync.Mutex
+	var wg sync.WaitGroup
+
+	queryTypes := []func() *filter.F{
+		func() *filter.F {
+			f := filter.New()
+			f.Kinds = kind.NewS(kind.TextNote)
+			limit := uint(100)
+			f.Limit = &limit
+			return f
+		},
+		func() *filter.F {
+			f := filter.New()
+			f.Kinds = kind.NewS(kind.TextNote, kind.Repost)
+			limit := uint(50)
+			f.Limit = &limit
+			return f
+		},
+		func() *filter.F {
+			f := filter.New()
+			limit := uint(10)
+			f.Limit = &limit
+			since := time.Now().Add(-1 * time.Hour).Unix()
+			f.Since = timestamp.FromUnix(since)
+			return f
+		},
+	}
+
+	// Run concurrent queries
+	iterations := 1000
+	for i := 0; i < ba.config.ConcurrentWorkers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			for j := 0; j < iterations/ba.config.ConcurrentWorkers; j++ {
+				f := queryTypes[j%len(queryTypes)]()
+
+				queryStart := time.Now()
+				_, _ = ba.db.QueryEvents(ctx, f)
+				latency := time.Since(queryStart)
+
+				mu.Lock()
+				queryCount++
+				latencies = append(latencies, latency)
+				mu.Unlock()
+			}
+		}()
+	}
+
+	wg.Wait()
+	duration := time.Since(start)
+
+	result := &BenchmarkResult{
+		TestName:          fmt.Sprintf("Query Performance (%d queries)", queryCount),
+		Duration:          duration,
+		TotalEvents:       int(queryCount),
+		EventsPerSecond:   float64(queryCount) / duration.Seconds(),
+		ConcurrentWorkers: ba.config.ConcurrentWorkers,
+		MemoryUsed:        getMemUsage(),
+		SuccessRate:       100.0,
+	}
+
+	if len(latencies) > 0 {
+		sort.Slice(latencies, func(i, j int) bool {
+			return latencies[i] < latencies[j]
+		})
+		result.AvgLatency = calculateAverage(latencies)
+		result.P90Latency = latencies[int(float64(len(latencies))*0.90)]
+		result.P95Latency = latencies[int(float64(len(latencies))*0.95)]
+		result.P99Latency = latencies[int(float64(len(latencies))*0.99)]
+
+		bottom10 := latencies[:int(float64(len(latencies))*0.10)]
+		result.Bottom10Avg = calculateAverage(bottom10)
+	}
+
+	ba.mu.Lock()
+	ba.results = append(ba.results, result)
+	ba.mu.Unlock()
+
+	ba.printResult(result)
+}
+
+// RunConcurrentQueryStoreTest runs concurrent query and store test
+func (ba *BenchmarkAdapter) RunConcurrentQueryStoreTest() {
+	fmt.Println("\n=== Concurrent Query+Store Test ===")
+
+	start := time.Now()
+	var storeCount, queryCount int64
+	var latencies []time.Duration
+	var mu sync.Mutex
+	var wg sync.WaitGroup
+
+	ctx := context.Background()
+
+	// Half workers write, half query
+	halfWorkers := ba.config.ConcurrentWorkers / 2
+	if halfWorkers < 1 {
+		halfWorkers = 1
+	}
+
+	// Writers
+	for i := 0; i < halfWorkers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			events := ba.generateEvents(ba.config.NumEvents / halfWorkers)
+			for _, ev := range events {
+				eventStart := time.Now()
+				ba.db.SaveEvent(ctx, ev)
+				latency := time.Since(eventStart)
+
+				mu.Lock()
+				storeCount++
+				latencies = append(latencies, latency)
+				mu.Unlock()
+			}
+		}()
+	}
+
+	// Readers
+	for i := 0; i < halfWorkers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			for j := 0; j < ba.config.NumEvents/halfWorkers; j++ {
+				f := filter.New()
+				f.Kinds = kind.NewS(kind.TextNote)
+				limit := uint(10)
+				f.Limit = &limit
+
+				queryStart := time.Now()
+				ba.db.QueryEvents(ctx, f)
+				latency := time.Since(queryStart)
+
+				mu.Lock()
+				queryCount++
+				latencies = append(latencies, latency)
+				mu.Unlock()
+
+				time.Sleep(1 * time.Millisecond)
+			}
+		}()
+	}
+
+	wg.Wait()
+	duration := time.Since(start)
+
+	result := &BenchmarkResult{
+		TestName:          fmt.Sprintf("Concurrent Q+S (Q:%d S:%d)", queryCount, storeCount),
+		Duration:          duration,
+		TotalEvents:       int(storeCount + queryCount),
+		EventsPerSecond:   float64(storeCount+queryCount) / duration.Seconds(),
+		ConcurrentWorkers: ba.config.ConcurrentWorkers,
+		MemoryUsed:        getMemUsage(),
+		SuccessRate:       100.0,
+	}
+
+	if len(latencies) > 0 {
+		sort.Slice(latencies, func(i, j int) bool {
+			return latencies[i] < latencies[j]
+		})
+		result.AvgLatency = calculateAverage(latencies)
+		result.P90Latency = latencies[int(float64(len(latencies))*0.90)]
+		result.P95Latency = latencies[int(float64(len(latencies))*0.95)]
+		result.P99Latency = latencies[int(float64(len(latencies))*0.99)]
+
+		bottom10 := latencies[:int(float64(len(latencies))*0.10)]
+		result.Bottom10Avg = calculateAverage(bottom10)
+	}
+
+	ba.mu.Lock()
+	ba.results = append(ba.results, result)
+	ba.mu.Unlock()
+
+	ba.printResult(result)
+}
+
+// generateEvents generates test events with proper signatures
+func (ba *BenchmarkAdapter) generateEvents(count int) []*event.E {
+	events := make([]*event.E, count)
+
+	// Create a test signer
+	signer := p8k.MustNew()
+	if err := signer.Generate(); err != nil {
+		panic(fmt.Sprintf("failed to generate test key: %v", err))
+	}
+
+	for i := 0; i < count; i++ {
+		ev := event.New()
+		ev.Kind = kind.TextNote.ToU16()
+		ev.CreatedAt = time.Now().Unix()
+		ev.Content = []byte(fmt.Sprintf("Benchmark event #%d - Testing Nostr relay performance with automated load generation", i))
+		ev.Tags = tag.NewS()
+
+		// Add some tags for variety
+		if i%10 == 0 {
+			benchmarkTag := tag.NewFromBytesSlice([]byte("t"), []byte("benchmark"))
+			ev.Tags.Append(benchmarkTag)
+		}
+
+		// Sign the event (sets Pubkey, ID, and Sig)
+		if err := ev.Sign(signer); err != nil {
+			panic(fmt.Sprintf("failed to sign event: %v", err))
+		}
+
+		events[i] = ev
+	}
+
+	return events
+}
+
+func (ba *BenchmarkAdapter) printResult(r *BenchmarkResult) {
+	fmt.Printf("\nResults for %s:\n", r.TestName)
+	fmt.Printf("  Duration: %v\n", r.Duration)
+	fmt.Printf("  Total Events: %d\n", r.TotalEvents)
+	fmt.Printf("  Events/sec: %.2f\n", r.EventsPerSecond)
+	fmt.Printf("  Success Rate: %.2f%%\n", r.SuccessRate)
+	fmt.Printf("  Workers: %d\n", r.ConcurrentWorkers)
+	fmt.Printf("  Memory Used: %.2f MB\n", float64(r.MemoryUsed)/1024/1024)
+
+	if r.AvgLatency > 0 {
+		fmt.Printf("  Avg Latency: %v\n", r.AvgLatency)
+		fmt.Printf("  P90 Latency: %v\n", r.P90Latency)
+		fmt.Printf("  P95 Latency: %v\n", r.P95Latency)
+		fmt.Printf("  P99 Latency: %v\n", r.P99Latency)
+		fmt.Printf("  Bottom 10%% Avg: %v\n", r.Bottom10Avg)
+	}
+
+	if len(r.Errors) > 0 {
+		fmt.Printf("  Errors: %d\n", len(r.Errors))
+		// Print first few errors as samples
+		sampleCount := 3
+		if len(r.Errors) < sampleCount {
+			sampleCount = len(r.Errors)
+		}
+		for i := 0; i < sampleCount; i++ {
+			fmt.Printf("    Sample %d: %s\n", i+1, r.Errors[i])
+		}
+	}
+}
+
+func (ba *BenchmarkAdapter) GenerateReport() {
+	// Delegate to main benchmark report generator
+	// We'll add the results to a file
+	fmt.Println("\n=== Benchmark Results Summary ===")
+	ba.mu.RLock()
+	defer ba.mu.RUnlock()
+
+	for _, result := range ba.results {
+		ba.printResult(result)
+	}
+}
+
+func (ba *BenchmarkAdapter) GenerateAsciidocReport() {
+	// TODO: Implement asciidoc report generation
+	fmt.Println("Asciidoc report generation not yet implemented for adapter")
+}
+
+func calculateAverage(durations []time.Duration) time.Duration {
+	if len(durations) == 0 {
+		return 0
+	}
+
+	var total time.Duration
+	for _, d := range durations {
+		total += d
+	}
+	return total / time.Duration(len(durations))
+}
--- a/cmd/benchmark/dgraph_benchmark.go
+++ b/cmd/benchmark/dgraph_benchmark.go
@@ -0,0 +1,122 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"time"
+
+	"next.orly.dev/pkg/database"
+	_ "next.orly.dev/pkg/dgraph" // Import to register dgraph factory
+)
+
+// DgraphBenchmark wraps a Benchmark with dgraph-specific setup
+type DgraphBenchmark struct {
+	config   *BenchmarkConfig
+	docker   *DgraphDocker
+	database database.Database
+	bench    *BenchmarkAdapter
+}
+
+// NewDgraphBenchmark creates a new dgraph benchmark instance
+func NewDgraphBenchmark(config *BenchmarkConfig) (*DgraphBenchmark, error) {
+	// Create Docker manager
+	docker := NewDgraphDocker()
+
+	// Start dgraph containers
+	ctx := context.Background()
+	if err := docker.Start(ctx); err != nil {
+		return nil, fmt.Errorf("failed to start dgraph: %w", err)
+	}
+
+	// Set environment variable for dgraph connection
+	os.Setenv("ORLY_DGRAPH_URL", docker.GetGRPCEndpoint())
+
+	// Create database instance using dgraph backend
+	cancel := func() {}
+	db, err := database.NewDatabase(ctx, cancel, "dgraph", config.DataDir, "warn")
+	if err != nil {
+		docker.Stop()
+		return nil, fmt.Errorf("failed to create dgraph database: %w", err)
+	}
+
+	// Wait for database to be ready
+	fmt.Println("Waiting for dgraph database to be ready...")
+	select {
+	case <-db.Ready():
+		fmt.Println("Dgraph database is ready")
+	case <-time.After(30 * time.Second):
+		db.Close()
+		docker.Stop()
+		return nil, fmt.Errorf("dgraph database failed to become ready")
+	}
+
+	// Create adapter to use Database interface with Benchmark
+	adapter := NewBenchmarkAdapter(config, db)
+
+	dgraphBench := &DgraphBenchmark{
+		config:   config,
+		docker:   docker,
+		database: db,
+		bench:    adapter,
+	}
+
+	return dgraphBench, nil
+}
+
+// Close closes the dgraph benchmark and stops Docker containers
+func (dgb *DgraphBenchmark) Close() {
+	fmt.Println("Closing dgraph benchmark...")
+
+	if dgb.database != nil {
+		dgb.database.Close()
+	}
+
+	if dgb.docker != nil {
+		if err := dgb.docker.Stop(); err != nil {
+			log.Printf("Error stopping dgraph Docker: %v", err)
+		}
+	}
+}
+
+// RunSuite runs the benchmark suite on dgraph
+func (dgb *DgraphBenchmark) RunSuite() {
+	fmt.Println("\n╔════════════════════════════════════════════════════════╗")
+	fmt.Println("║         DGRAPH BACKEND BENCHMARK SUITE                 ║")
+	fmt.Println("╚════════════════════════════════════════════════════════╝")
+
+	// Run only one round for dgraph to keep benchmark time reasonable
+	fmt.Printf("\n=== Starting dgraph benchmark ===\n")
+
+	fmt.Printf("RunPeakThroughputTest (dgraph)..\n")
+	dgb.bench.RunPeakThroughputTest()
+	time.Sleep(10 * time.Second)
+
+	fmt.Printf("RunBurstPatternTest (dgraph)..\n")
+	dgb.bench.RunBurstPatternTest()
+	time.Sleep(10 * time.Second)
+
+	fmt.Printf("RunMixedReadWriteTest (dgraph)..\n")
+	dgb.bench.RunMixedReadWriteTest()
+	time.Sleep(10 * time.Second)
+
+	fmt.Printf("RunQueryTest (dgraph)..\n")
+	dgb.bench.RunQueryTest()
+	time.Sleep(10 * time.Second)
+
+	fmt.Printf("RunConcurrentQueryStoreTest (dgraph)..\n")
+	dgb.bench.RunConcurrentQueryStoreTest()
+
+	fmt.Printf("\n=== Dgraph benchmark completed ===\n\n")
+}
+
+// GenerateReport generates the benchmark report
+func (dgb *DgraphBenchmark) GenerateReport() {
+	dgb.bench.GenerateReport()
+}
+
+// GenerateAsciidocReport generates asciidoc format report
+func (dgb *DgraphBenchmark) GenerateAsciidocReport() {
+	dgb.bench.GenerateAsciidocReport()
+}
--- a/cmd/benchmark/dgraph_docker.go
+++ b/cmd/benchmark/dgraph_docker.go
@@ -0,0 +1,160 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+)
+
+// DgraphDocker manages a dgraph instance via Docker Compose
+type DgraphDocker struct {
+	composeFile string
+	projectName string
+	running     bool
+}
+
+// NewDgraphDocker creates a new dgraph Docker manager
+func NewDgraphDocker() *DgraphDocker {
+	// Try to find the docker-compose file in the current directory first
+	composeFile := "docker-compose-dgraph.yml"
+
+	// If not found, try the cmd/benchmark directory (for running from project root)
+	if _, err := os.Stat(composeFile); os.IsNotExist(err) {
+		composeFile = filepath.Join("cmd", "benchmark", "docker-compose-dgraph.yml")
+	}
+
+	return &DgraphDocker{
+		composeFile: composeFile,
+		projectName: "orly-benchmark-dgraph",
+		running:     false,
+	}
+}
+
+// Start starts the dgraph Docker containers
+func (d *DgraphDocker) Start(ctx context.Context) error {
+	fmt.Println("Starting dgraph Docker containers...")
+
+	// Stop any existing containers first
+	d.Stop()
+
+	// Start containers
+	cmd := exec.CommandContext(
+		ctx,
+		"docker-compose",
+		"-f", d.composeFile,
+		"-p", d.projectName,
+		"up", "-d",
+	)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to start dgraph containers: %w", err)
+	}
+
+	fmt.Println("Waiting for dgraph to be healthy...")
+
+	// Wait for health checks to pass
+	if err := d.waitForHealthy(ctx, 60*time.Second); err != nil {
+		d.Stop() // Clean up on failure
+		return err
+	}
+
+	d.running = true
+	fmt.Println("Dgraph is ready!")
+	return nil
+}
+
+// waitForHealthy waits for dgraph to become healthy
+func (d *DgraphDocker) waitForHealthy(ctx context.Context, timeout time.Duration) error {
+	deadline := time.Now().Add(timeout)
+
+	for time.Now().Before(deadline) {
+		// Check if alpha is healthy by checking docker health status
+		cmd := exec.CommandContext(
+			ctx,
+			"docker",
+			"inspect",
+			"--format={{.State.Health.Status}}",
+			"orly-benchmark-dgraph-alpha",
+		)
+
+		output, err := cmd.Output()
+		if err == nil && string(output) == "healthy\n" {
+			// Additional short wait to ensure full readiness
+			time.Sleep(2 * time.Second)
+			return nil
+		}
+
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-time.After(2 * time.Second):
+			// Continue waiting
+		}
+	}
+
+	return fmt.Errorf("dgraph failed to become healthy within %v", timeout)
+}
+
+// Stop stops and removes the dgraph Docker containers
+func (d *DgraphDocker) Stop() error {
+	if !d.running {
+		// Try to stop anyway in case of untracked state
+		cmd := exec.Command(
+			"docker-compose",
+			"-f", d.composeFile,
+			"-p", d.projectName,
+			"down", "-v",
+		)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		_ = cmd.Run() // Ignore errors
+		return nil
+	}
+
+	fmt.Println("Stopping dgraph Docker containers...")
+
+	cmd := exec.Command(
+		"docker-compose",
+		"-f", d.composeFile,
+		"-p", d.projectName,
+		"down", "-v",
+	)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to stop dgraph containers: %w", err)
+	}
+
+	d.running = false
+	fmt.Println("Dgraph containers stopped")
+	return nil
+}
+
+// GetGRPCEndpoint returns the dgraph gRPC endpoint
+func (d *DgraphDocker) GetGRPCEndpoint() string {
+	return "localhost:9080"
+}
+
+// IsRunning returns whether dgraph is running
+func (d *DgraphDocker) IsRunning() bool {
+	return d.running
+}
+
+// Logs returns the logs from dgraph containers
+func (d *DgraphDocker) Logs() error {
+	cmd := exec.Command(
+		"docker-compose",
+		"-f", d.composeFile,
+		"-p", d.projectName,
+		"logs",
+	)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
--- a/cmd/benchmark/docker-compose-dgraph.yml
+++ b/cmd/benchmark/docker-compose-dgraph.yml
@@ -0,0 +1,44 @@
+version: "3.9"
+
+services:
+  dgraph-zero:
+    image: dgraph/dgraph:v23.1.0
+    container_name: orly-benchmark-dgraph-zero
+    working_dir: /data/zero
+    ports:
+      - "5080:5080"
+      - "6080:6080"
+    command: dgraph zero --my=dgraph-zero:5080
+    networks:
+      - orly-benchmark
+    healthcheck:
+      test: ["CMD", "sh", "-c", "dgraph version || exit 1"]
+      interval: 5s
+      timeout: 3s
+      retries: 3
+      start_period: 5s
+
+  dgraph-alpha:
+    image: dgraph/dgraph:v23.1.0
+    container_name: orly-benchmark-dgraph-alpha
+    working_dir: /data/alpha
+    ports:
+      - "8080:8080"
+      - "9080:9080"
+    command: dgraph alpha --my=dgraph-alpha:7080 --zero=dgraph-zero:5080 --security whitelist=0.0.0.0/0
+    networks:
+      - orly-benchmark
+    depends_on:
+      dgraph-zero:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "sh", "-c", "dgraph version || exit 1"]
+      interval: 5s
+      timeout: 3s
+      retries: 6
+      start_period: 10s
+
+networks:
+  orly-benchmark:
+    name: orly-benchmark-network
+    driver: bridge
--- a/cmd/benchmark/docker-compose.yml
+++ b/cmd/benchmark/docker-compose.yml
@@ -1,19 +1,20 @@
 version: "3.8"

 services:
-  # Next.orly.dev relay (this repository)
-  next-orly:
+  # Next.orly.dev relay with Badger (this repository)
+  next-orly-badger:
    build:
      context: ../..
      dockerfile: cmd/benchmark/Dockerfile.next-orly
-    container_name: benchmark-next-orly
+    container_name: benchmark-next-orly-badger
    environment:
      - ORLY_DATA_DIR=/data
      - ORLY_LISTEN=0.0.0.0
      - ORLY_PORT=8080
      - ORLY_LOG_LEVEL=off
+      - ORLY_DB_TYPE=badger
    volumes:
-      - ./data/next-orly:/data
+      - ./data/next-orly-badger:/data
    ports:
      - "8001:8080"
    networks:
@@ -25,6 +26,78 @@ services:
      retries: 3
      start_period: 40s

+  # Next.orly.dev relay with DGraph (this repository)
+  next-orly-dgraph:
+    build:
+      context: ../..
+      dockerfile: cmd/benchmark/Dockerfile.next-orly
+    container_name: benchmark-next-orly-dgraph
+    environment:
+      - ORLY_DATA_DIR=/data
+      - ORLY_LISTEN=0.0.0.0
+      - ORLY_PORT=8080
+      - ORLY_LOG_LEVEL=off
+      - ORLY_DB_TYPE=dgraph
+      - ORLY_DGRAPH_URL=dgraph-alpha:9080
+    volumes:
+      - ./data/next-orly-dgraph:/data
+    ports:
+      - "8007:8080"
+    networks:
+      - benchmark-net
+    depends_on:
+      dgraph-alpha:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 60s
+
+  # DGraph Zero - cluster coordinator
+  dgraph-zero:
+    image: dgraph/dgraph:v23.1.0
+    container_name: benchmark-dgraph-zero
+    working_dir: /data/zero
+    ports:
+      - "5080:5080"
+      - "6080:6080"
+    volumes:
+      - ./data/dgraph-zero:/data
+    command: dgraph zero --my=dgraph-zero:5080
+    networks:
+      - benchmark-net
+    healthcheck:
+      test: ["CMD", "sh", "-c", "dgraph version || exit 1"]
+      interval: 5s
+      timeout: 3s
+      retries: 3
+      start_period: 5s
+
+  # DGraph Alpha - data node
+  dgraph-alpha:
+    image: dgraph/dgraph:v23.1.0
+    container_name: benchmark-dgraph-alpha
+    working_dir: /data/alpha
+    ports:
+      - "8088:8080"
+      - "9080:9080"
+    volumes:
+      - ./data/dgraph-alpha:/data
+    command: dgraph alpha --my=dgraph-alpha:7080 --zero=dgraph-zero:5080 --security whitelist=0.0.0.0/0
+    networks:
+      - benchmark-net
+    depends_on:
+      dgraph-zero:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "sh", "-c", "dgraph version || exit 1"]
+      interval: 5s
+      timeout: 3s
+      retries: 6
+      start_period: 10s
+
  # Khatru with SQLite
  khatru-sqlite:
    build:
@@ -145,7 +218,9 @@ services:
      dockerfile: cmd/benchmark/Dockerfile.benchmark
    container_name: benchmark-runner
    depends_on:
-      next-orly:
+      next-orly-badger:
+        condition: service_healthy
+      next-orly-dgraph:
        condition: service_healthy
      khatru-sqlite:
        condition: service_healthy
@@ -158,7 +233,7 @@ services:
      nostr-rs-relay:
        condition: service_healthy
    environment:
-      - BENCHMARK_TARGETS=next-orly:8080,khatru-sqlite:3334,khatru-badger:3334,relayer-basic:7447,strfry:8080,nostr-rs-relay:8080
+      - BENCHMARK_TARGETS=next-orly-badger:8080,next-orly-dgraph:8080,khatru-sqlite:3334,khatru-badger:3334,relayer-basic:7447,strfry:8080,nostr-rs-relay:8080
      - BENCHMARK_EVENTS=50000
      - BENCHMARK_WORKERS=24
      - BENCHMARK_DURATION=60s
--- a/cmd/benchmark/event_stream.go
+++ b/cmd/benchmark/event_stream.go
@@ -0,0 +1,257 @@
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"math"
+	"math/rand"
+	"os"
+	"path/filepath"
+	"time"
+
+	"next.orly.dev/pkg/encoders/event"
+	"next.orly.dev/pkg/encoders/tag"
+	"next.orly.dev/pkg/encoders/timestamp"
+	"next.orly.dev/pkg/interfaces/signer/p8k"
+)
+
+// EventStream manages disk-based event generation to avoid memory bloat
+type EventStream struct {
+	baseDir   string
+	count     int
+	chunkSize int
+	rng       *rand.Rand
+}
+
+// NewEventStream creates a new event stream that stores events on disk
+func NewEventStream(baseDir string, count int) (*EventStream, error) {
+	// Create events directory
+	eventsDir := filepath.Join(baseDir, "events")
+	if err := os.MkdirAll(eventsDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create events directory: %w", err)
+	}
+
+	return &EventStream{
+		baseDir:   eventsDir,
+		count:     count,
+		chunkSize: 1000, // Store 1000 events per file to balance I/O
+		rng:       rand.New(rand.NewSource(time.Now().UnixNano())),
+	}, nil
+}
+
+// Generate creates all events and stores them in chunk files
+func (es *EventStream) Generate() error {
+	numChunks := (es.count + es.chunkSize - 1) / es.chunkSize
+
+	for chunk := 0; chunk < numChunks; chunk++ {
+		chunkFile := filepath.Join(es.baseDir, fmt.Sprintf("chunk_%04d.jsonl", chunk))
+		f, err := os.Create(chunkFile)
+		if err != nil {
+			return fmt.Errorf("failed to create chunk file %s: %w", chunkFile, err)
+		}
+
+		writer := bufio.NewWriter(f)
+		startIdx := chunk * es.chunkSize
+		endIdx := min(startIdx+es.chunkSize, es.count)
+
+		for i := startIdx; i < endIdx; i++ {
+			ev, err := es.generateEvent(i)
+			if err != nil {
+				f.Close()
+				return fmt.Errorf("failed to generate event %d: %w", i, err)
+			}
+
+			// Marshal event to JSON
+			eventJSON, err := json.Marshal(ev)
+			if err != nil {
+				f.Close()
+				return fmt.Errorf("failed to marshal event %d: %w", i, err)
+			}
+
+			// Write JSON line
+			if _, err := writer.Write(eventJSON); err != nil {
+				f.Close()
+				return fmt.Errorf("failed to write event %d: %w", i, err)
+			}
+			if _, err := writer.WriteString("\n"); err != nil {
+				f.Close()
+				return fmt.Errorf("failed to write newline after event %d: %w", i, err)
+			}
+		}
+
+		if err := writer.Flush(); err != nil {
+			f.Close()
+			return fmt.Errorf("failed to flush chunk file %s: %w", chunkFile, err)
+		}
+
+		if err := f.Close(); err != nil {
+			return fmt.Errorf("failed to close chunk file %s: %w", chunkFile, err)
+		}
+
+		if (chunk+1)%10 == 0 || chunk == numChunks-1 {
+			fmt.Printf("  Generated %d/%d events (%.1f%%)\n",
+				endIdx, es.count, float64(endIdx)/float64(es.count)*100)
+		}
+	}
+
+	return nil
+}
+
+// generateEvent creates a single event with realistic size distribution
+func (es *EventStream) generateEvent(index int) (*event.E, error) {
+	// Create signer for this event
+	keys, err := p8k.New()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create signer: %w", err)
+	}
+	if err := keys.Generate(); err != nil {
+		return nil, fmt.Errorf("failed to generate keys: %w", err)
+	}
+
+	ev := event.New()
+	ev.Kind = 1 // Text note
+	ev.CreatedAt = timestamp.Now().I64()
+
+	// Add some tags for realism
+	numTags := es.rng.Intn(5)
+	tags := make([]*tag.T, 0, numTags)
+	for i := 0; i < numTags; i++ {
+		tags = append(tags, tag.NewFromBytesSlice(
+			[]byte("t"),
+			[]byte(fmt.Sprintf("tag%d", es.rng.Intn(100))),
+		))
+	}
+	ev.Tags = tag.NewS(tags...)
+
+	// Generate content with log-distributed size
+	contentSize := es.generateLogDistributedSize()
+	ev.Content = []byte(es.generateRandomContent(contentSize))
+
+	// Sign the event
+	if err := ev.Sign(keys); err != nil {
+		return nil, fmt.Errorf("failed to sign event: %w", err)
+	}
+
+	return ev, nil
+}
+
+// generateLogDistributedSize generates sizes following a power law distribution
+// This creates realistic size distribution:
+// - Most events are small (< 1KB)
+// - Some events are medium (1-10KB)
+// - Few events are large (10-100KB)
+func (es *EventStream) generateLogDistributedSize() int {
+	// Use power law with exponent 4.0 for strong skew toward small sizes
+	const powerExponent = 4.0
+	uniform := es.rng.Float64()
+	skewed := math.Pow(uniform, powerExponent)
+
+	// Scale to max size of 100KB
+	const maxSize = 100 * 1024
+	size := int(skewed * maxSize)
+
+	// Ensure minimum size of 10 bytes
+	if size < 10 {
+		size = 10
+	}
+
+	return size
+}
+
+// generateRandomContent creates random text content of specified size
+func (es *EventStream) generateRandomContent(size int) string {
+	const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 \n"
+	content := make([]byte, size)
+	for i := range content {
+		content[i] = charset[es.rng.Intn(len(charset))]
+	}
+	return string(content)
+}
+
+// GetEventChannel returns a channel that streams events from disk
+// bufferSize controls memory usage - larger buffers improve throughput but use more memory
+func (es *EventStream) GetEventChannel(bufferSize int) (<-chan *event.E, <-chan error) {
+	eventChan := make(chan *event.E, bufferSize)
+	errChan := make(chan error, 1)
+
+	go func() {
+		defer close(eventChan)
+		defer close(errChan)
+
+		numChunks := (es.count + es.chunkSize - 1) / es.chunkSize
+
+		for chunk := 0; chunk < numChunks; chunk++ {
+			chunkFile := filepath.Join(es.baseDir, fmt.Sprintf("chunk_%04d.jsonl", chunk))
+			f, err := os.Open(chunkFile)
+			if err != nil {
+				errChan <- fmt.Errorf("failed to open chunk file %s: %w", chunkFile, err)
+				return
+			}
+
+			scanner := bufio.NewScanner(f)
+			// Increase buffer size for large events
+			buf := make([]byte, 0, 64*1024)
+			scanner.Buffer(buf, 1024*1024) // Max 1MB per line
+
+			for scanner.Scan() {
+				var ev event.E
+				if err := json.Unmarshal(scanner.Bytes(), &ev); err != nil {
+					f.Close()
+					errChan <- fmt.Errorf("failed to unmarshal event: %w", err)
+					return
+				}
+				eventChan <- &ev
+			}
+
+			if err := scanner.Err(); err != nil {
+				f.Close()
+				errChan <- fmt.Errorf("error reading chunk file %s: %w", chunkFile, err)
+				return
+			}
+
+			f.Close()
+		}
+	}()
+
+	return eventChan, errChan
+}
+
+// ForEach iterates over all events without loading them all into memory
+func (es *EventStream) ForEach(fn func(*event.E) error) error {
+	numChunks := (es.count + es.chunkSize - 1) / es.chunkSize
+
+	for chunk := 0; chunk < numChunks; chunk++ {
+		chunkFile := filepath.Join(es.baseDir, fmt.Sprintf("chunk_%04d.jsonl", chunk))
+		f, err := os.Open(chunkFile)
+		if err != nil {
+			return fmt.Errorf("failed to open chunk file %s: %w", chunkFile, err)
+		}
+
+		scanner := bufio.NewScanner(f)
+		buf := make([]byte, 0, 64*1024)
+		scanner.Buffer(buf, 1024*1024)
+
+		for scanner.Scan() {
+			var ev event.E
+			if err := json.Unmarshal(scanner.Bytes(), &ev); err != nil {
+				f.Close()
+				return fmt.Errorf("failed to unmarshal event: %w", err)
+			}
+
+			if err := fn(&ev); err != nil {
+				f.Close()
+				return err
+			}
+		}
+
+		if err := scanner.Err(); err != nil {
+			f.Close()
+			return fmt.Errorf("error reading chunk file %s: %w", chunkFile, err)
+		}
+
+		f.Close()
+	}
+
+	return nil
+}
--- a/cmd/benchmark/latency_recorder.go
+++ b/cmd/benchmark/latency_recorder.go
@@ -0,0 +1,173 @@
+package main
+
+import (
+	"bufio"
+	"encoding/binary"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"sync"
+	"time"
+)
+
+// LatencyRecorder writes latency measurements to disk to avoid memory bloat
+type LatencyRecorder struct {
+	file   *os.File
+	writer *bufio.Writer
+	mu     sync.Mutex
+	count  int64
+}
+
+// LatencyStats contains calculated latency statistics
+type LatencyStats struct {
+	Avg        time.Duration
+	P90        time.Duration
+	P95        time.Duration
+	P99        time.Duration
+	Bottom10   time.Duration
+	Count      int64
+}
+
+// NewLatencyRecorder creates a new latency recorder that writes to disk
+func NewLatencyRecorder(baseDir string, testName string) (*LatencyRecorder, error) {
+	latencyFile := filepath.Join(baseDir, fmt.Sprintf("latency_%s.bin", testName))
+	f, err := os.Create(latencyFile)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create latency file: %w", err)
+	}
+
+	return &LatencyRecorder{
+		file:   f,
+		writer: bufio.NewWriter(f),
+		count:  0,
+	}, nil
+}
+
+// Record writes a latency measurement to disk (8 bytes per measurement)
+func (lr *LatencyRecorder) Record(latency time.Duration) error {
+	lr.mu.Lock()
+	defer lr.mu.Unlock()
+
+	// Write latency as 8-byte value (int64 nanoseconds)
+	buf := make([]byte, 8)
+	binary.LittleEndian.PutUint64(buf, uint64(latency.Nanoseconds()))
+
+	if _, err := lr.writer.Write(buf); err != nil {
+		return fmt.Errorf("failed to write latency: %w", err)
+	}
+
+	lr.count++
+	return nil
+}
+
+// Close flushes and closes the latency file
+func (lr *LatencyRecorder) Close() error {
+	lr.mu.Lock()
+	defer lr.mu.Unlock()
+
+	if err := lr.writer.Flush(); err != nil {
+		return fmt.Errorf("failed to flush latency file: %w", err)
+	}
+
+	if err := lr.file.Close(); err != nil {
+		return fmt.Errorf("failed to close latency file: %w", err)
+	}
+
+	return nil
+}
+
+// CalculateStats reads all latencies from disk, sorts them, and calculates statistics
+// This is done on-demand to avoid keeping all latencies in memory during the test
+func (lr *LatencyRecorder) CalculateStats() (*LatencyStats, error) {
+	lr.mu.Lock()
+	filePath := lr.file.Name()
+	count := lr.count
+	lr.mu.Unlock()
+
+	// If no measurements, return zeros
+	if count == 0 {
+		return &LatencyStats{
+			Avg:        0,
+			P90:        0,
+			P95:        0,
+			P99:        0,
+			Bottom10:   0,
+			Count:      0,
+		}, nil
+	}
+
+	// Open file for reading
+	f, err := os.Open(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open latency file for reading: %w", err)
+	}
+	defer f.Close()
+
+	// Read all latencies into memory temporarily for sorting
+	latencies := make([]time.Duration, 0, count)
+	buf := make([]byte, 8)
+	reader := bufio.NewReader(f)
+
+	for {
+		n, err := reader.Read(buf)
+		if err != nil {
+			if err.Error() == "EOF" {
+				break
+			}
+			return nil, fmt.Errorf("failed to read latency data: %w", err)
+		}
+		if n != 8 {
+			break
+		}
+
+		nanos := binary.LittleEndian.Uint64(buf)
+		latencies = append(latencies, time.Duration(nanos))
+	}
+
+	// Check if we actually got any latencies
+	if len(latencies) == 0 {
+		return &LatencyStats{
+			Avg:        0,
+			P90:        0,
+			P95:        0,
+			P99:        0,
+			Bottom10:   0,
+			Count:      0,
+		}, nil
+	}
+
+	// Sort for percentile calculation
+	sort.Slice(latencies, func(i, j int) bool {
+		return latencies[i] < latencies[j]
+	})
+
+	// Calculate statistics
+	stats := &LatencyStats{
+		Count: int64(len(latencies)),
+	}
+
+	// Average
+	var sum time.Duration
+	for _, lat := range latencies {
+		sum += lat
+	}
+	stats.Avg = sum / time.Duration(len(latencies))
+
+	// Percentiles
+	stats.P90 = latencies[int(float64(len(latencies))*0.90)]
+	stats.P95 = latencies[int(float64(len(latencies))*0.95)]
+	stats.P99 = latencies[int(float64(len(latencies))*0.99)]
+
+	// Bottom 10% average
+	bottom10Count := int(float64(len(latencies)) * 0.10)
+	if bottom10Count > 0 {
+		var bottom10Sum time.Duration
+		for i := 0; i < bottom10Count; i++ {
+			bottom10Sum += latencies[i]
+		}
+		stats.Bottom10 = bottom10Sum / time.Duration(bottom10Count)
+	}
+
+	return stats, nil
+}
--- a/cmd/benchmark/main.go
+++ b/cmd/benchmark/main.go
@@ -36,6 +36,9 @@ type BenchmarkConfig struct {
 	RelayURL   string
 	NetWorkers int
 	NetRate    int // events/sec per worker
+
+	// Backend selection
+	UseDgraph bool
 }

 type BenchmarkResult struct {
@@ -55,10 +58,11 @@ type BenchmarkResult struct {
 }

 type Benchmark struct {
-	config  *BenchmarkConfig
-	db      *database.D
-	results []*BenchmarkResult
-	mu      sync.RWMutex
+	config      *BenchmarkConfig
+	db          *database.D
+	eventStream *EventStream
+	results     []*BenchmarkResult
+	mu          sync.RWMutex
 }

 func main() {
@@ -71,7 +75,14 @@ func main() {
 		return
 	}

-	fmt.Printf("Starting Nostr Relay Benchmark\n")
+	if config.UseDgraph {
+		// Run dgraph benchmark
+		runDgraphBenchmark(config)
+		return
+	}
+
+	// Run standard Badger benchmark
+	fmt.Printf("Starting Nostr Relay Benchmark (Badger Backend)\n")
 	fmt.Printf("Data Directory: %s\n", config.DataDir)
 	fmt.Printf(
 		"Events: %d, Workers: %d, Duration: %v\n",
@@ -89,6 +100,28 @@ func main() {
 	benchmark.GenerateAsciidocReport()
 }

+func runDgraphBenchmark(config *BenchmarkConfig) {
+	fmt.Printf("Starting Nostr Relay Benchmark (Dgraph Backend)\n")
+	fmt.Printf("Data Directory: %s\n", config.DataDir)
+	fmt.Printf(
+		"Events: %d, Workers: %d\n",
+		config.NumEvents, config.ConcurrentWorkers,
+	)
+
+	dgraphBench, err := NewDgraphBenchmark(config)
+	if err != nil {
+		log.Fatalf("Failed to create dgraph benchmark: %v", err)
+	}
+	defer dgraphBench.Close()
+
+	// Run dgraph benchmark suite
+	dgraphBench.RunSuite()
+
+	// Generate reports
+	dgraphBench.GenerateReport()
+	dgraphBench.GenerateAsciidocReport()
+}
+
 func parseFlags() *BenchmarkConfig {
 	config := &BenchmarkConfig{}

@@ -124,6 +157,12 @@ func parseFlags() *BenchmarkConfig {
 	)
 	flag.IntVar(&config.NetRate, "net-rate", 20, "Events per second per worker")

+	// Backend selection
+	flag.BoolVar(
+		&config.UseDgraph, "dgraph", false,
+		"Use dgraph backend (requires Docker)",
+	)
+
 	flag.Parse()
 	return config
 }
@@ -286,15 +325,28 @@ func NewBenchmark(config *BenchmarkConfig) *Benchmark {
 	ctx := context.Background()
 	cancel := func() {}

-	db, err := database.New(ctx, cancel, config.DataDir, "info")
+	db, err := database.New(ctx, cancel, config.DataDir, "warn")
 	if err != nil {
 		log.Fatalf("Failed to create database: %v", err)
 	}

+	// Create event stream (stores events on disk to avoid memory bloat)
+	eventStream, err := NewEventStream(config.DataDir, config.NumEvents)
+	if err != nil {
+		log.Fatalf("Failed to create event stream: %v", err)
+	}
+
+	// Pre-generate all events to disk
+	fmt.Printf("Pre-generating %d events to disk to avoid memory bloat...\n", config.NumEvents)
+	if err := eventStream.Generate(); err != nil {
+		log.Fatalf("Failed to generate events: %v", err)
+	}
+
 	b := &Benchmark{
-		config:  config,
-		db:      db,
-		results: make([]*BenchmarkResult, 0),
+		config:      config,
+		db:          db,
+		eventStream: eventStream,
+		results:     make([]*BenchmarkResult, 0),
 	}

 	// Trigger compaction/GC before starting tests
@@ -309,31 +361,49 @@ func (b *Benchmark) Close() {
 	}
 }

-// RunSuite runs the three tests with a 10s pause between them and repeats the
-// set twice with a 10s pause between rounds.
+// RunSuite runs the memory-optimized tests (Peak Throughput and Burst Pattern only)
 func (b *Benchmark) RunSuite() {
-	for round := 1; round <= 2; round++ {
-		fmt.Printf("\n=== Starting test round %d/2 ===\n", round)
-		fmt.Printf("RunPeakThroughputTest..\n")
-		b.RunPeakThroughputTest()
-		time.Sleep(10 * time.Second)
-		fmt.Printf("RunBurstPatternTest..\n")
-		b.RunBurstPatternTest()
-		time.Sleep(10 * time.Second)
-		fmt.Printf("RunMixedReadWriteTest..\n")
-		b.RunMixedReadWriteTest()
-		time.Sleep(10 * time.Second)
-		fmt.Printf("RunQueryTest..\n")
-		b.RunQueryTest()
-		time.Sleep(10 * time.Second)
-		fmt.Printf("RunConcurrentQueryStoreTest..\n")
-		b.RunConcurrentQueryStoreTest()
-		if round < 2 {
-			fmt.Printf("\nPausing 10s before next round...\n")
-			time.Sleep(10 * time.Second)
-		}
-		fmt.Printf("\n=== Test round completed ===\n\n")
+	fmt.Printf("\n=== Running Memory-Optimized Tests ===\n")
+
+	fmt.Printf("RunPeakThroughputTest..\n")
+	b.RunPeakThroughputTest()
+
+	// Clear database between tests to avoid duplicate event issues
+	fmt.Printf("\nClearing database for next test...\n")
+	if err := b.db.Close(); err != nil {
+		log.Printf("Error closing database: %v", err)
 	}
+	time.Sleep(1 * time.Second)
+
+	// Remove database files (.sst, .vlog, MANIFEST, etc.)
+	// Badger stores files directly in the data directory
+	matches, err := filepath.Glob(filepath.Join(b.config.DataDir, "*.sst"))
+	if err == nil {
+		for _, f := range matches {
+			os.Remove(f)
+		}
+	}
+	matches, err = filepath.Glob(filepath.Join(b.config.DataDir, "*.vlog"))
+	if err == nil {
+		for _, f := range matches {
+			os.Remove(f)
+		}
+	}
+	os.Remove(filepath.Join(b.config.DataDir, "MANIFEST"))
+	os.Remove(filepath.Join(b.config.DataDir, "DISCARD"))
+	os.Remove(filepath.Join(b.config.DataDir, "KEYREGISTRY"))
+
+	// Create fresh database
+	ctx := context.Background()
+	cancel := func() {}
+	db, err := database.New(ctx, cancel, b.config.DataDir, "warn")
+	if err != nil {
+		log.Fatalf("Failed to create fresh database: %v", err)
+	}
+	b.db = db
+
+	fmt.Printf("RunBurstPatternTest..\n")
+	b.RunBurstPatternTest()
 }

 // compactDatabase triggers a Badger value log GC before starting tests.
@@ -348,50 +418,71 @@ func (b *Benchmark) compactDatabase() {
 func (b *Benchmark) RunPeakThroughputTest() {
 	fmt.Println("\n=== Peak Throughput Test ===")

+	// Create latency recorder (writes to disk, not memory)
+	latencyRecorder, err := NewLatencyRecorder(b.config.DataDir, "peak_throughput")
+	if err != nil {
+		log.Fatalf("Failed to create latency recorder: %v", err)
+	}
+
 	start := time.Now()
 	var wg sync.WaitGroup
 	var totalEvents int64
-	var errors []error
-	var latencies []time.Duration
+	var errorCount int64
 	var mu sync.Mutex

-	events := b.generateEvents(b.config.NumEvents)
-	eventChan := make(chan *event.E, len(events))
-
-	// Fill event channel
-	for _, ev := range events {
-		eventChan <- ev
-	}
-	close(eventChan)
+	// Stream events from disk with reasonable buffer
+	eventChan, errChan := b.eventStream.GetEventChannel(1000)

 	// Start workers
+	ctx := context.Background()
 	for i := 0; i < b.config.ConcurrentWorkers; i++ {
 		wg.Add(1)
 		go func(workerID int) {
 			defer wg.Done()

-			ctx := context.Background()
 			for ev := range eventChan {
 				eventStart := time.Now()
-
 				_, err := b.db.SaveEvent(ctx, ev)
 				latency := time.Since(eventStart)

 				mu.Lock()
 				if err != nil {
-					errors = append(errors, err)
+					errorCount++
 				} else {
 					totalEvents++
-					latencies = append(latencies, latency)
+					if err := latencyRecorder.Record(latency); err != nil {
+						log.Printf("Failed to record latency: %v", err)
+					}
 				}
 				mu.Unlock()
 			}
 		}(i)
 	}

+	// Check for streaming errors
+	go func() {
+		for err := range errChan {
+			if err != nil {
+				log.Printf("Event stream error: %v", err)
+			}
+		}
+	}()
+
 	wg.Wait()
 	duration := time.Since(start)

+	// Flush latency data to disk before calculating stats
+	if err := latencyRecorder.Close(); err != nil {
+		log.Printf("Failed to close latency recorder: %v", err)
+	}
+
+	// Calculate statistics from disk
+	latencyStats, err := latencyRecorder.CalculateStats()
+	if err != nil {
+		log.Printf("Failed to calculate latency stats: %v", err)
+		latencyStats = &LatencyStats{}
+	}
+
 	// Calculate metrics
 	result := &BenchmarkResult{
 		TestName:          "Peak Throughput",
@@ -400,29 +491,22 @@ func (b *Benchmark) RunPeakThroughputTest() {
 		EventsPerSecond:   float64(totalEvents) / duration.Seconds(),
 		ConcurrentWorkers: b.config.ConcurrentWorkers,
 		MemoryUsed:        getMemUsage(),
-	}
-
-	if len(latencies) > 0 {
-		result.AvgLatency = calculateAvgLatency(latencies)
-		result.P90Latency = calculatePercentileLatency(latencies, 0.90)
-		result.P95Latency = calculatePercentileLatency(latencies, 0.95)
-		result.P99Latency = calculatePercentileLatency(latencies, 0.99)
-		result.Bottom10Avg = calculateBottom10Avg(latencies)
+		AvgLatency:        latencyStats.Avg,
+		P90Latency:        latencyStats.P90,
+		P95Latency:        latencyStats.P95,
+		P99Latency:        latencyStats.P99,
+		Bottom10Avg:       latencyStats.Bottom10,
 	}

 	result.SuccessRate = float64(totalEvents) / float64(b.config.NumEvents) * 100

-	for _, err := range errors {
-		result.Errors = append(result.Errors, err.Error())
-	}
-
 	b.mu.Lock()
 	b.results = append(b.results, result)
 	b.mu.Unlock()

 	fmt.Printf(
-		"Events saved: %d/%d (%.1f%%)\n", totalEvents, b.config.NumEvents,
-		result.SuccessRate,
+		"Events saved: %d/%d (%.1f%%), errors: %d\n",
+		totalEvents, b.config.NumEvents, result.SuccessRate, errorCount,
 	)
 	fmt.Printf("Duration: %v\n", duration)
 	fmt.Printf("Events/sec: %.2f\n", result.EventsPerSecond)
@@ -436,14 +520,28 @@ func (b *Benchmark) RunPeakThroughputTest() {
 func (b *Benchmark) RunBurstPatternTest() {
 	fmt.Println("\n=== Burst Pattern Test ===")

+	// Create latency recorder (writes to disk, not memory)
+	latencyRecorder, err := NewLatencyRecorder(b.config.DataDir, "burst_pattern")
+	if err != nil {
+		log.Fatalf("Failed to create latency recorder: %v", err)
+	}
+
 	start := time.Now()
 	var totalEvents int64
-	var errors []error
-	var latencies []time.Duration
+	var errorCount int64
 	var mu sync.Mutex

-	// Generate events for burst pattern
-	events := b.generateEvents(b.config.NumEvents)
+	// Stream events from disk
+	eventChan, errChan := b.eventStream.GetEventChannel(500)
+
+	// Check for streaming errors
+	go func() {
+		for err := range errChan {
+			if err != nil {
+				log.Printf("Event stream error: %v", err)
+			}
+		}
+	}()

 	// Simulate burst pattern: high activity periods followed by quiet periods
 	burstSize := b.config.NumEvents / 10 // 10% of events in each burst
@@ -451,37 +549,51 @@ func (b *Benchmark) RunBurstPatternTest() {
 	burstPeriod := 100 * time.Millisecond

 	ctx := context.Background()
-	eventIndex := 0
+	var eventIndex int64

-	for eventIndex < len(events) && time.Since(start) < b.config.TestDuration {
-		// Burst period - send events rapidly
-		burstStart := time.Now()
-		var wg sync.WaitGroup
-
-		for i := 0; i < burstSize && eventIndex < len(events); i++ {
-			wg.Add(1)
-			go func(ev *event.E) {
-				defer wg.Done()
+	// Start persistent worker pool (prevents goroutine explosion)
+	numWorkers := b.config.ConcurrentWorkers
+	eventQueue := make(chan *event.E, numWorkers*4)
+	var wg sync.WaitGroup

+	for w := 0; w < numWorkers; w++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for ev := range eventQueue {
 				eventStart := time.Now()
 				_, err := b.db.SaveEvent(ctx, ev)
 				latency := time.Since(eventStart)

 				mu.Lock()
 				if err != nil {
-					errors = append(errors, err)
+					errorCount++
 				} else {
 					totalEvents++
-					latencies = append(latencies, latency)
+					// Record latency to disk instead of keeping in memory
+					if err := latencyRecorder.Record(latency); err != nil {
+						log.Printf("Failed to record latency: %v", err)
+					}
 				}
 				mu.Unlock()
-			}(events[eventIndex])
+			}
+		}()
+	}

+	for int(eventIndex) < b.config.NumEvents && time.Since(start) < b.config.TestDuration {
+		// Burst period - send events rapidly
+		burstStart := time.Now()
+
+		for i := 0; i < burstSize && int(eventIndex) < b.config.NumEvents; i++ {
+			ev, ok := <-eventChan
+			if !ok {
+				break
+			}
+			eventQueue <- ev
 			eventIndex++
 			time.Sleep(burstPeriod / time.Duration(burstSize))
 		}

-		wg.Wait()
 		fmt.Printf(
 			"Burst completed: %d events in %v\n", burstSize,
 			time.Since(burstStart),
@@ -491,8 +603,23 @@ func (b *Benchmark) RunBurstPatternTest() {
 		time.Sleep(quietPeriod)
 	}

+	close(eventQueue)
+	wg.Wait()
+
 	duration := time.Since(start)

+	// Flush latency data to disk before calculating stats
+	if err := latencyRecorder.Close(); err != nil {
+		log.Printf("Failed to close latency recorder: %v", err)
+	}
+
+	// Calculate statistics from disk
+	latencyStats, err := latencyRecorder.CalculateStats()
+	if err != nil {
+		log.Printf("Failed to calculate latency stats: %v", err)
+		latencyStats = &LatencyStats{}
+	}
+
 	// Calculate metrics
 	result := &BenchmarkResult{
 		TestName:          "Burst Pattern",
@@ -501,27 +628,23 @@ func (b *Benchmark) RunBurstPatternTest() {
 		EventsPerSecond:   float64(totalEvents) / duration.Seconds(),
 		ConcurrentWorkers: b.config.ConcurrentWorkers,
 		MemoryUsed:        getMemUsage(),
-	}
-
-	if len(latencies) > 0 {
-		result.AvgLatency = calculateAvgLatency(latencies)
-		result.P90Latency = calculatePercentileLatency(latencies, 0.90)
-		result.P95Latency = calculatePercentileLatency(latencies, 0.95)
-		result.P99Latency = calculatePercentileLatency(latencies, 0.99)
-		result.Bottom10Avg = calculateBottom10Avg(latencies)
+		AvgLatency:        latencyStats.Avg,
+		P90Latency:        latencyStats.P90,
+		P95Latency:        latencyStats.P95,
+		P99Latency:        latencyStats.P99,
+		Bottom10Avg:       latencyStats.Bottom10,
 	}

 	result.SuccessRate = float64(totalEvents) / float64(eventIndex) * 100

-	for _, err := range errors {
-		result.Errors = append(result.Errors, err.Error())
-	}
-
 	b.mu.Lock()
 	b.results = append(b.results, result)
 	b.mu.Unlock()

-	fmt.Printf("Burst test completed: %d events in %v\n", totalEvents, duration)
+	fmt.Printf(
+		"Burst test completed: %d events in %v, errors: %d\n",
+		totalEvents, duration, errorCount,
+	)
 	fmt.Printf("Events/sec: %.2f\n", result.EventsPerSecond)
 }

@@ -974,7 +1097,7 @@ func (b *Benchmark) generateEvents(count int) []*event.E {
 		log.Fatalf("Failed to generate keys for benchmark events: %v", err)
 	}

-	// Define size distribution - from minimal to 500MB
+	// Define size distribution - from minimal to 500KB
 	// We'll create a logarithmic distribution to test various sizes
 	sizeBuckets := []int{
 		0,          // Minimal: empty content, no tags
@@ -984,13 +1107,8 @@ func (b *Benchmark) generateEvents(count int) []*event.E {
 		10 * 1024,  // 10 KB
 		50 * 1024,  // 50 KB
 		100 * 1024, // 100 KB
-		500 * 1024, // 500 KB
-		1024 * 1024,      // 1 MB
-		5 * 1024 * 1024,  // 5 MB
-		10 * 1024 * 1024, // 10 MB
-		50 * 1024 * 1024, // 50 MB
-		100 * 1024 * 1024, // 100 MB
-		500000000,  // 500 MB (500,000,000 bytes)
+		250 * 1024, // 250 KB
+		500 * 1024, // 500 KB (max realistic size for Nostr)
 	}

 	for i := 0; i < count; i++ {
--- a/cmd/benchmark/reports/run_20251117_154730/next-orly_results.txt
+++ b/cmd/benchmark/reports/run_20251117_154730/next-orly_results.txt
@@ -0,0 +1,134 @@
+Starting Nostr Relay Benchmark
+Data Directory: /tmp/benchmark_next-orly_8
+Events: 50000, Workers: 24, Duration: 1m0s
+1763394450181444ℹ️ /tmp/benchmark_next-orly_8: All 0 tables opened in 0s
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/levels.go:161 /build/pkg/database/logger.go:56
+1763394450184981ℹ️ /tmp/benchmark_next-orly_8: Discard stats nextEmptySlot: 0
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/discard.go:55 /build/pkg/database/logger.go:56
+1763394450185044ℹ️ /tmp/benchmark_next-orly_8: Set nextTxnTs to 0
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:358 /build/pkg/database/logger.go:56
+1763394450185315ℹ️ migrating to version 1... /build/pkg/database/migrations.go:66
+1763394450185349ℹ️ migrating to version 2... /build/pkg/database/migrations.go:73
+1763394450185369ℹ️ migrating to version 3... /build/pkg/database/migrations.go:80
+1763394450185374ℹ️ cleaning up ephemeral events (kinds 20000-29999)... /build/pkg/database/migrations.go:287
+1763394450185381ℹ️ cleaned up 0 ephemeral events from database /build/pkg/database/migrations.go:332
+1763394450185396ℹ️ migrating to version 4... /build/pkg/database/migrations.go:87
+1763394450185400ℹ️ converting events to optimized inline storage (Reiser4 optimization)... /build/pkg/database/migrations.go:340
+1763394450185410ℹ️ found 0 events to convert (0 regular, 0 replaceable, 0 addressable) /build/pkg/database/migrations.go:429
+1763394450185415ℹ️ migration complete: converted 0 events to optimized inline storage, deleted 0 old keys /build/pkg/database/migrations.go:538
+
+=== Starting test round 1/2 ===
+RunPeakThroughputTest..
+
+=== Peak Throughput Test ===
+2025/11/17 15:47:30 INFO: Successfully loaded libsecp256k1 v5.0.0 from libsecp256k1.so.2
+1763394452185466ℹ️ /tmp/benchmark_next-orly_8: database warmup complete, ready to serve requests
+/usr/local/go/src/runtime/asm_amd64.s:1693 /build/pkg/database/logger.go:56
+Events saved: 50000/50000 (100.0%)
+Duration: 4.816237891s
+Events/sec: 10381.55
+Avg latency: 1.655686ms
+P90 latency: 2.061483ms
+P95 latency: 2.348178ms
+P99 latency: 3.856522ms
+Bottom 10% Avg latency: 2.985064ms
+RunBurstPatternTest..
+
+=== Burst Pattern Test ===
+Burst completed: 5000 events in 308.793395ms
+Burst completed: 5000 events in 320.69366ms
+Burst completed: 5000 events in 324.127721ms
+Burst completed: 5000 events in 342.594802ms
+Burst completed: 5000 events in 302.350819ms
+Burst completed: 5000 events in 309.16143ms
+Burst completed: 5000 events in 306.739193ms
+Burst completed: 5000 events in 329.275972ms
+Burst completed: 5000 events in 329.234395ms
+Burst completed: 5000 events in 348.105403ms
+Burst test completed: 50000 events in 9.543815189s
+Events/sec: 5238.99
+RunMixedReadWriteTest..
+
+=== Mixed Read/Write Test ===
+Pre-populating database for read tests...
+Mixed test completed: 25000 writes, 25000 reads in 24.491349518s
+Combined ops/sec: 2041.54
+1763394510174043ℹ️ /tmp/benchmark_next-orly_8: Block cache metrics: hit: 248593 miss: 322620 keys-added: 236208 keys-updated: 73483 keys-evicted: 236188 cost-added: 12658387393408 cost-evicted: 12657366958988 sets-dropped: 0 sets-rejected: 12869 gets-dropped: 64 gets-kept: 570624 gets-total: 571213 hit-ratio: 0.44
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:454 /build/pkg/database/logger.go:56
+RunQueryTest..
+
+=== Query Test ===
+Pre-populating database with 10000 events for query tests...
+Query test completed: 258436 queries in 1m0.014042961s
+Queries/sec: 4306.26
+Avg query latency: 4.008354ms
+P95 query latency: 12.985167ms
+P99 query latency: 23.424372ms
+RunConcurrentQueryStoreTest..
+
+=== Concurrent Query/Store Test ===
+Pre-populating database with 5000 events for concurrent query/store test...
+Concurrent test completed: 252445 operations (202445 queries, 50000 writes) in 1m0.005913119s
+Operations/sec: 4207.00
+Avg latency: 2.121776ms
+Avg query latency: 2.374689ms
+Avg write latency: 1.097756ms
+P95 latency: 3.545393ms
+P99 latency: 4.795537ms
+
+Pausing 10s before next round...
+
+=== Test round completed ===
+
+
+=== Starting test round 2/2 ===
+RunPeakThroughputTest..
+
+=== Peak Throughput Test ===
+Events saved: 50000/50000 (100.0%)
+Duration: 5.086723437s
+Events/sec: 9829.51
+Avg latency: 1.777699ms
+P90 latency: 2.219786ms
+P95 latency: 2.443201ms
+P99 latency: 3.504646ms
+Bottom 10% Avg latency: 3.103013ms
+RunBurstPatternTest..
+
+=== Burst Pattern Test ===
+Burst completed: 5000 events in 324.341799ms
+Burst completed: 5000 events in 319.047042ms
+Burst completed: 5000 events in 324.104589ms
+Burst completed: 5000 events in 342.464953ms
+Burst completed: 5000 events in 342.679451ms
+Burst completed: 5000 events in 359.150337ms
+Burst completed: 5000 events in 367.952516ms
+Burst completed: 5000 events in 338.4073ms
+Burst completed: 5000 events in 326.796197ms
+Burst completed: 5000 events in 357.71787ms
+Burst test completed: 50000 events in 9.769325434s
+Events/sec: 5118.06
+1763394684274617ℹ️ /tmp/benchmark_next-orly_8: [4] [E] LOG Compact 0->6 (8, 0 -> 4 tables with 1 splits). [00001 00002 00003 00004 00005 00006 00007 00008 . .] -> [00009 00010 00011 00012 .], took 2.954s
+, deleted 1904950 bytes
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/levels.go:1479 /build/pkg/database/logger.go:56
+RunMixedReadWriteTest..
+
+=== Mixed Read/Write Test ===
+Pre-populating database for read tests...
+Mixed test completed: 25000 writes, 25000 reads in 24.464062793s
+Combined ops/sec: 2043.81
+RunQueryTest..
+
+=== Query Test ===
+Pre-populating database with 10000 events for query tests...
+Query test completed: 293040 queries in 1m0.010621036s
+Queries/sec: 4883.14
+Avg query latency: 3.419764ms
+P95 query latency: 11.042876ms
+P99 query latency: 19.984912ms
+RunConcurrentQueryStoreTest..
+
+=== Concurrent Query/Store Test ===
+Pre-populating database with 5000 events for concurrent query/store test...
+1763394810173629ℹ️ /tmp/benchmark_next-orly_8: Block cache metrics: hit: 517421289 miss: 4606293 keys-added: 1664534 keys-updated: 2530425 keys-evicted: 1664512 cost-added: 85045328540032 cost-evicted: 85044318079141 sets-dropped: 0 sets-rejected: 349798 gets-dropped: 404194112 gets-kept: 117717888 gets-total: 522027608 hit-ratio: 0.99
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:454 /build/pkg/database/logger.go:56
--- a/cmd/benchmark/reports/run_20251117_161622/khatru-badger_results.txt
+++ b/cmd/benchmark/reports/run_20251117_161622/khatru-badger_results.txt
@@ -0,0 +1,53 @@
+Starting Nostr Relay Benchmark
+Data Directory: /tmp/benchmark_khatru-badger_8
+Events: 50000, Workers: 24, Duration: 1m0s
+1763397432159815ℹ️ /tmp/benchmark_khatru-badger_8: All 0 tables opened in 0s
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/levels.go:161 /build/pkg/database/logger.go:56
+1763397432162963ℹ️ /tmp/benchmark_khatru-badger_8: Discard stats nextEmptySlot: 0
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/discard.go:55 /build/pkg/database/logger.go:56
+1763397432163005ℹ️ /tmp/benchmark_khatru-badger_8: Set nextTxnTs to 0
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:358 /build/pkg/database/logger.go:56
+1763397432163282ℹ️ migrating to version 1... /build/pkg/database/migrations.go:66
+1763397432163367ℹ️ migrating to version 2... /build/pkg/database/migrations.go:73
+1763397432163401ℹ️ migrating to version 3... /build/pkg/database/migrations.go:80
+1763397432163409ℹ️ cleaning up ephemeral events (kinds 20000-29999)... /build/pkg/database/migrations.go:287
+1763397432163473ℹ️ cleaned up 0 ephemeral events from database /build/pkg/database/migrations.go:332
+1763397432163564ℹ️ migrating to version 4... /build/pkg/database/migrations.go:87
+1763397432163574ℹ️ converting events to optimized inline storage (Reiser4 optimization)... /build/pkg/database/migrations.go:340
+1763397432163594ℹ️ found 0 events to convert (0 regular, 0 replaceable, 0 addressable) /build/pkg/database/migrations.go:429
+1763397432163600ℹ️ migration complete: converted 0 events to optimized inline storage, deleted 0 old keys /build/pkg/database/migrations.go:538
+
+=== Starting test round 1/2 ===
+RunPeakThroughputTest..
+
+=== Peak Throughput Test ===
+2025/11/17 16:37:12 INFO: Successfully loaded libsecp256k1 v5.0.0 from libsecp256k1.so.2
+1763397434164165ℹ️ /tmp/benchmark_khatru-badger_8: database warmup complete, ready to serve requests
+/usr/local/go/src/runtime/asm_amd64.s:1693 /build/pkg/database/logger.go:56
+Events saved: 50000/50000 (100.0%)
+Duration: 4.924203666s
+Events/sec: 10153.93
+Avg latency: 1.696974ms
+P90 latency: 2.11483ms
+P95 latency: 2.344067ms
+P99 latency: 3.241477ms
+Bottom 10% Avg latency: 2.7865ms
+RunBurstPatternTest..
+
+=== Burst Pattern Test ===
+Burst completed: 5000 events in 312.680497ms
+Burst completed: 5000 events in 320.868898ms
+Burst completed: 5000 events in 317.096109ms
+Burst completed: 5000 events in 356.971689ms
+Burst completed: 5000 events in 301.615682ms
+Burst completed: 5000 events in 306.525096ms
+Burst completed: 5000 events in 320.037813ms
+Burst completed: 5000 events in 318.017102ms
+Burst completed: 5000 events in 320.394281ms
+Burst completed: 5000 events in 333.619741ms
+Burst test completed: 50000 events in 9.552105607s
+Events/sec: 5234.45
+RunMixedReadWriteTest..
+
+=== Mixed Read/Write Test ===
+Pre-populating database for read tests...
--- a/cmd/benchmark/reports/run_20251117_161622/khatru-sqlite_results.txt
+++ b/cmd/benchmark/reports/run_20251117_161622/khatru-sqlite_results.txt
@@ -0,0 +1,323 @@
+Starting Nostr Relay Benchmark
+Data Directory: /tmp/benchmark_khatru-sqlite_8
+Events: 50000, Workers: 24, Duration: 1m0s
+1763397017138391ℹ️ /tmp/benchmark_khatru-sqlite_8: All 0 tables opened in 0s
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/levels.go:161 /build/pkg/database/logger.go:56
+1763397017141550ℹ️ /tmp/benchmark_khatru-sqlite_8: Discard stats nextEmptySlot: 0
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/discard.go:55 /build/pkg/database/logger.go:56
+1763397017141593ℹ️ /tmp/benchmark_khatru-sqlite_8: Set nextTxnTs to 0
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:358 /build/pkg/database/logger.go:56
+1763397017141951ℹ️ migrating to version 1... /build/pkg/database/migrations.go:66
+1763397017142013ℹ️ migrating to version 2... /build/pkg/database/migrations.go:73
+1763397017142036ℹ️ migrating to version 3... /build/pkg/database/migrations.go:80
+1763397017142042ℹ️ cleaning up ephemeral events (kinds 20000-29999)... /build/pkg/database/migrations.go:287
+1763397017142055ℹ️ cleaned up 0 ephemeral events from database /build/pkg/database/migrations.go:332
+1763397017142080ℹ️ migrating to version 4... /build/pkg/database/migrations.go:87
+1763397017142086ℹ️ converting events to optimized inline storage (Reiser4 optimization)... /build/pkg/database/migrations.go:340
+1763397017142103ℹ️ found 0 events to convert (0 regular, 0 replaceable, 0 addressable) /build/pkg/database/migrations.go:429
+1763397017142109ℹ️ migration complete: converted 0 events to optimized inline storage, deleted 0 old keys /build/pkg/database/migrations.go:538
+
+=== Starting test round 1/2 ===
+RunPeakThroughputTest..
+
+=== Peak Throughput Test ===
+2025/11/17 16:30:17 INFO: Successfully loaded libsecp256k1 v5.0.0 from libsecp256k1.so.2
+1763397019142156ℹ️ /tmp/benchmark_khatru-sqlite_8: database warmup complete, ready to serve requests
+/usr/local/go/src/runtime/asm_amd64.s:1693 /build/pkg/database/logger.go:56
+Events saved: 50000/50000 (100.0%)
+Duration: 4.697220167s
+Events/sec: 10644.59
+Avg latency: 1.589521ms
+P90 latency: 1.927686ms
+P95 latency: 2.072081ms
+P99 latency: 2.794007ms
+Bottom 10% Avg latency: 2.449508ms
+RunBurstPatternTest..
+
+=== Burst Pattern Test ===
+Burst completed: 5000 events in 331.053594ms
+Burst completed: 5000 events in 339.97436ms
+Burst completed: 5000 events in 352.328844ms
+Burst completed: 5000 events in 376.613834ms
+Burst completed: 5000 events in 321.307729ms
+Burst completed: 5000 events in 314.265411ms
+Burst completed: 5000 events in 321.656622ms
+Burst completed: 5000 events in 325.689539ms
+Burst completed: 5000 events in 367.767832ms
+Burst completed: 5000 events in 367.275402ms
+Burst test completed: 50000 events in 9.780316233s
+Events/sec: 5112.31
+RunMixedReadWriteTest..
+
+=== Mixed Read/Write Test ===
+Pre-populating database for read tests...
+Mixed test completed: 25000 writes, 25000 reads in 24.45356557s
+Combined ops/sec: 2044.69
+1763397077132611⚠️ /tmp/benchmark_khatru-sqlite_8: Block cache might be too small. Metrics: hit: 164850 miss: 294509 keys-added: 226622 keys-updated: 54881 keys-evicted: 226603 cost-added: 12429978548485 cost-evicted: 12428976154843 sets-dropped: 0 sets-rejected: 12954 gets-dropped: 192 gets-kept: 458368 gets-total: 459359 hit-ratio: 0.36
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:450 /build/pkg/database/logger.go:46
+1763397077132680⚠️ /tmp/benchmark_khatru-sqlite_8: Cache life expectancy (in seconds): 
+ -- Histogram: 
+Min value: 0 
+Max value: 11 
+Count: 226603 
+50p: 2.00 
+75p: 2.00 
+90p: 2.00 
+[0, 2) 226567 99.98% 99.98%
+[8, 16) 36 0.02% 100.00%
+ --
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:451 /build/pkg/database/logger.go:46
+RunQueryTest..
+
+=== Query Test ===
+Pre-populating database with 10000 events for query tests...
+Query test completed: 253442 queries in 1m0.011742602s
+Queries/sec: 4223.21
+Avg query latency: 4.105842ms
+P95 query latency: 13.288591ms
+P99 query latency: 23.937862ms
+RunConcurrentQueryStoreTest..
+
+=== Concurrent Query/Store Test ===
+Pre-populating database with 5000 events for concurrent query/store test...
+Concurrent test completed: 237910 operations (187910 queries, 50000 writes) in 1m0.007412985s
+Operations/sec: 3964.68
+Avg latency: 2.360698ms
+Avg query latency: 2.630397ms
+Avg write latency: 1.347113ms
+P95 latency: 4.390739ms
+P99 latency: 6.940329ms
+
+Pausing 10s before next round...
+
+=== Test round completed ===
+
+
+=== Starting test round 2/2 ===
+RunPeakThroughputTest..
+
+=== Peak Throughput Test ===
+Events saved: 50000/50000 (100.0%)
+Duration: 4.792392684s
+Events/sec: 10433.20
+Avg latency: 1.649743ms
+P90 latency: 1.991666ms
+P95 latency: 2.145348ms
+P99 latency: 2.77034ms
+Bottom 10% Avg latency: 2.781523ms
+RunBurstPatternTest..
+
+=== Burst Pattern Test ===
+Burst completed: 5000 events in 330.357755ms
+Burst completed: 5000 events in 334.984623ms
+Burst completed: 5000 events in 345.478382ms
+Burst completed: 5000 events in 340.589233ms
+Burst completed: 5000 events in 348.792025ms
+Burst completed: 5000 events in 354.019658ms
+Burst completed: 5000 events in 356.823662ms
+Burst completed: 5000 events in 347.496865ms
+Burst completed: 5000 events in 342.618798ms
+Burst completed: 5000 events in 337.759666ms
+Burst test completed: 50000 events in 9.775603327s
+Events/sec: 5114.77
+1763397250998218ℹ️ /tmp/benchmark_khatru-sqlite_8: [6] [E] LOG Compact 0->6 (8, 0 -> 4 tables with 1 splits). [00001 00002 00003 00004 00005 00006 00007 00008 . .] -> [00009 00010 00011 00012 .], took 2.922s
+, deleted 1932516 bytes
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/levels.go:1479 /build/pkg/database/logger.go:56
+RunMixedReadWriteTest..
+
+=== Mixed Read/Write Test ===
+Pre-populating database for read tests...
+Mixed test completed: 25000 writes, 25000 reads in 24.35620806s
+Combined ops/sec: 2052.86
+RunQueryTest..
+
+=== Query Test ===
+Pre-populating database with 10000 events for query tests...
+Query test completed: 334922 queries in 1m0.011826287s
+Queries/sec: 5580.93
+Avg query latency: 2.871941ms
+P95 query latency: 8.86787ms
+P99 query latency: 16.075646ms
+RunConcurrentQueryStoreTest..
+
+=== Concurrent Query/Store Test ===
+Pre-populating database with 5000 events for concurrent query/store test...
+1763397377131811ℹ️ /tmp/benchmark_khatru-sqlite_8: Block cache metrics: hit: 485497199 miss: 4802603 keys-added: 1628313 keys-updated: 2776240 keys-evicted: 1628292 cost-added: 85662348259200 cost-evicted: 85661362474446 sets-dropped: 0 sets-rejected: 336231 gets-dropped: 382997632 gets-kept: 107185536 gets-total: 490299843 hit-ratio: 0.99
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:454 /build/pkg/database/logger.go:56
+Concurrent test completed: 266462 operations (216462 queries, 50000 writes) in 1m0.004503525s
+Operations/sec: 4440.70
+Avg latency: 1.968296ms
+Avg query latency: 2.154689ms
+Avg write latency: 1.161355ms
+P95 latency: 3.329033ms
+P99 latency: 4.878236ms
+
+=== Test round completed ===
+
+
+================================================================================
+BENCHMARK REPORT
+================================================================================
+
+Test: Peak Throughput
+Duration: 4.697220167s
+Total Events: 50000
+Events/sec: 10644.59
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 432 MB
+Avg Latency: 1.589521ms
+P90 Latency: 1.927686ms
+P95 Latency: 2.072081ms
+P99 Latency: 2.794007ms
+Bottom 10% Avg Latency: 2.449508ms
+----------------------------------------
+
+Test: Burst Pattern
+Duration: 9.780316233s
+Total Events: 50000
+Events/sec: 5112.31
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 147 MB
+Avg Latency: 3.589724ms
+P90 Latency: 7.397294ms
+P95 Latency: 9.015658ms
+P99 Latency: 12.848707ms
+Bottom 10% Avg Latency: 10.286462ms
+----------------------------------------
+
+Test: Mixed Read/Write
+Duration: 24.45356557s
+Total Events: 50000
+Events/sec: 2044.69
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 189 MB
+Avg Latency: 439.984µs
+P90 Latency: 878.495µs
+P95 Latency: 980.94µs
+P99 Latency: 1.17514ms
+Bottom 10% Avg Latency: 1.261937ms
+----------------------------------------
+
+Test: Query Performance
+Duration: 1m0.011742602s
+Total Events: 253442
+Events/sec: 4223.21
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 165 MB
+Avg Latency: 4.105842ms
+P90 Latency: 8.468483ms
+P95 Latency: 13.288591ms
+P99 Latency: 23.937862ms
+Bottom 10% Avg Latency: 15.251447ms
+----------------------------------------
+
+Test: Concurrent Query/Store
+Duration: 1m0.007412985s
+Total Events: 237910
+Events/sec: 3964.68
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 149 MB
+Avg Latency: 2.360698ms
+P90 Latency: 3.517024ms
+P95 Latency: 4.390739ms
+P99 Latency: 6.940329ms
+Bottom 10% Avg Latency: 5.015416ms
+----------------------------------------
+
+Test: Peak Throughput
+Duration: 4.792392684s
+Total Events: 50000
+Events/sec: 10433.20
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 523 MB
+Avg Latency: 1.649743ms
+P90 Latency: 1.991666ms
+P95 Latency: 2.145348ms
+P99 Latency: 2.77034ms
+Bottom 10% Avg Latency: 2.781523ms
+----------------------------------------
+
+Test: Burst Pattern
+Duration: 9.775603327s
+Total Events: 50000
+Events/sec: 5114.77
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 541 MB
+Avg Latency: 2.925486ms
+P90 Latency: 5.542703ms
+P95 Latency: 7.775478ms
+P99 Latency: 11.125804ms
+Bottom 10% Avg Latency: 8.91184ms
+----------------------------------------
+
+Test: Mixed Read/Write
+Duration: 24.35620806s
+Total Events: 50000
+Events/sec: 2052.86
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 200 MB
+Avg Latency: 424.333µs
+P90 Latency: 865.429µs
+P95 Latency: 968.085µs
+P99 Latency: 1.174568ms
+Bottom 10% Avg Latency: 1.224002ms
+----------------------------------------
+
+Test: Query Performance
+Duration: 1m0.011826287s
+Total Events: 334922
+Events/sec: 5580.93
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 129 MB
+Avg Latency: 2.871941ms
+P90 Latency: 5.60422ms
+P95 Latency: 8.86787ms
+P99 Latency: 16.075646ms
+Bottom 10% Avg Latency: 10.23636ms
+----------------------------------------
+
+Test: Concurrent Query/Store
+Duration: 1m0.004503525s
+Total Events: 266462
+Events/sec: 4440.70
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 155 MB
+Avg Latency: 1.968296ms
+P90 Latency: 2.729181ms
+P95 Latency: 3.329033ms
+P99 Latency: 4.878236ms
+Bottom 10% Avg Latency: 3.768185ms
+----------------------------------------
+
+Report saved to: /tmp/benchmark_khatru-sqlite_8/benchmark_report.txt
+AsciiDoc report saved to: /tmp/benchmark_khatru-sqlite_8/benchmark_report.adoc
+1763397425682348ℹ️ /tmp/benchmark_khatru-sqlite_8: Lifetime L0 stalled for: 0s
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:536 /build/pkg/database/logger.go:56
+1763397426982581ℹ️ /tmp/benchmark_khatru-sqlite_8: 
+Level 0 [ ]: NumTables: 00. Size: 0 B of 0 B. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 1 [ ]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 2 [ ]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 3 [ ]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 4 [B]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 5 [ ]: NumTables: 01. Size: 94 MiB of 23 MiB. Score: 4.08->4.08 StaleData: 0 B Target FileSize: 122 MiB
+Level 6 [ ]: NumTables: 04. Size: 230 MiB of 230 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 244 MiB
+Level Done
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:615 /build/pkg/database/logger.go:56
+
+RELAY_NAME: khatru-sqlite
+RELAY_URL: ws://khatru-sqlite:3334
+TEST_TIMESTAMP: 2025-11-17T16:37:07+00:00
+BENCHMARK_CONFIG:
+  Events: 50000
+  Workers: 24
+  Duration: 60s
--- a/cmd/benchmark/reports/run_20251117_161622/next-orly-badger_results.txt
+++ b/cmd/benchmark/reports/run_20251117_161622/next-orly-badger_results.txt
@@ -0,0 +1,311 @@
+Starting Nostr Relay Benchmark
+Data Directory: /tmp/benchmark_next-orly-badger_8
+Events: 50000, Workers: 24, Duration: 1m0s
+1763396182850462ℹ️ /tmp/benchmark_next-orly-badger_8: All 0 tables opened in 0s
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/levels.go:161 /build/pkg/database/logger.go:56
+1763396182853668ℹ️ /tmp/benchmark_next-orly-badger_8: Discard stats nextEmptySlot: 0
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/discard.go:55 /build/pkg/database/logger.go:56
+1763396182853712ℹ️ /tmp/benchmark_next-orly-badger_8: Set nextTxnTs to 0
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:358 /build/pkg/database/logger.go:56
+1763396182854009ℹ️ migrating to version 1... /build/pkg/database/migrations.go:66
+1763396182854056ℹ️ migrating to version 2... /build/pkg/database/migrations.go:73
+1763396182854078ℹ️ migrating to version 3... /build/pkg/database/migrations.go:80
+1763396182854082ℹ️ cleaning up ephemeral events (kinds 20000-29999)... /build/pkg/database/migrations.go:287
+1763396182854129ℹ️ cleaned up 0 ephemeral events from database /build/pkg/database/migrations.go:332
+1763396182854260ℹ️ migrating to version 4... /build/pkg/database/migrations.go:87
+1763396182854271ℹ️ converting events to optimized inline storage (Reiser4 optimization)... /build/pkg/database/migrations.go:340
+1763396182854295ℹ️ found 0 events to convert (0 regular, 0 replaceable, 0 addressable) /build/pkg/database/migrations.go:429
+1763396182854302ℹ️ migration complete: converted 0 events to optimized inline storage, deleted 0 old keys /build/pkg/database/migrations.go:538
+
+=== Starting test round 1/2 ===
+RunPeakThroughputTest..
+
+=== Peak Throughput Test ===
+2025/11/17 16:16:22 INFO: Successfully loaded libsecp256k1 v5.0.0 from libsecp256k1.so.2
+1763396184854370ℹ️ /tmp/benchmark_next-orly-badger_8: database warmup complete, ready to serve requests
+/usr/local/go/src/runtime/asm_amd64.s:1693 /build/pkg/database/logger.go:56
+Events saved: 50000/50000 (100.0%)
+Duration: 5.666497805s
+Events/sec: 8823.79
+Avg latency: 2.020722ms
+P90 latency: 2.645436ms
+P95 latency: 2.995948ms
+P99 latency: 4.460502ms
+Bottom 10% Avg latency: 3.520179ms
+RunBurstPatternTest..
+
+=== Burst Pattern Test ===
+Burst completed: 5000 events in 352.025605ms
+Burst completed: 5000 events in 363.623929ms
+Burst completed: 5000 events in 367.475139ms
+Burst completed: 5000 events in 396.276199ms
+Burst completed: 5000 events in 334.007635ms
+Burst completed: 5000 events in 342.086817ms
+Burst completed: 5000 events in 360.687805ms
+Burst completed: 5000 events in 392.627451ms
+Burst completed: 5000 events in 397.635203ms
+Burst completed: 5000 events in 376.061572ms
+Burst test completed: 50000 events in 10.132858185s
+Events/sec: 4934.44
+RunMixedReadWriteTest..
+
+=== Mixed Read/Write Test ===
+Pre-populating database for read tests...
+1763396242843490ℹ️ /tmp/benchmark_next-orly-badger_8: Block cache metrics: hit: 232171 miss: 337826 keys-added: 235144 keys-updated: 89642 keys-evicted: 235124 cost-added: 12615246695866 cost-evicted: 12614243474391 sets-dropped: 0 sets-rejected: 12961 gets-dropped: 1280 gets-kept: 568192 gets-total: 569997 hit-ratio: 0.41
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:454 /build/pkg/database/logger.go:56
+Mixed test completed: 25000 writes, 25000 reads in 24.625333257s
+Combined ops/sec: 2030.43
+RunQueryTest..
+
+=== Query Test ===
+Pre-populating database with 10000 events for query tests...
+Query test completed: 197562 queries in 1m0.011972513s
+Queries/sec: 3292.04
+Avg query latency: 5.52205ms
+P95 query latency: 18.40165ms
+P99 query latency: 32.139723ms
+RunConcurrentQueryStoreTest..
+
+=== Concurrent Query/Store Test ===
+Pre-populating database with 5000 events for concurrent query/store test...
+Concurrent test completed: 224870 operations (174870 queries, 50000 writes) in 1m0.006047854s
+Operations/sec: 3747.46
+Avg latency: 2.665369ms
+Avg query latency: 2.866192ms
+Avg write latency: 1.963009ms
+P95 latency: 5.204253ms
+P99 latency: 8.129537ms
+
+Pausing 10s before next round...
+
+=== Test round completed ===
+
+
+=== Starting test round 2/2 ===
+RunPeakThroughputTest..
+
+=== Peak Throughput Test ===
+Events saved: 50000/50000 (100.0%)
+Duration: 5.145620568s
+Events/sec: 9717.00
+Avg latency: 1.788996ms
+P90 latency: 2.241725ms
+P95 latency: 2.442669ms
+P99 latency: 3.110506ms
+Bottom 10% Avg latency: 3.016821ms
+RunBurstPatternTest..
+
+=== Burst Pattern Test ===
+Burst completed: 5000 events in 362.292309ms
+Burst completed: 5000 events in 446.105376ms
+Burst completed: 5000 events in 414.443306ms
+Burst completed: 5000 events in 378.792051ms
+Burst completed: 5000 events in 381.274883ms
+Burst completed: 5000 events in 397.941224ms
+Burst completed: 5000 events in 449.109795ms
+Burst completed: 5000 events in 410.566974ms
+Burst completed: 5000 events in 385.220958ms
+Burst completed: 5000 events in 383.149443ms
+1763396419122547ℹ️ /tmp/benchmark_next-orly-badger_8: [0] [E] LOG Compact 0->6 (8, 0 -> 4 tables with 1 splits). [00001 00002 00003 00004 00005 00006 00007 00008 . .] -> [00009 00010 00011 00012 .], took 3.061s
+, deleted 1899050 bytes
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/levels.go:1479 /build/pkg/database/logger.go:56
+Burst test completed: 50000 events in 10.438224172s
+Events/sec: 4790.09
+RunMixedReadWriteTest..
+
+=== Mixed Read/Write Test ===
+Pre-populating database for read tests...
+Mixed test completed: 25000 writes, 25000 reads in 24.485622359s
+Combined ops/sec: 2042.01
+RunQueryTest..
+
+=== Query Test ===
+Pre-populating database with 10000 events for query tests...
+Query test completed: 293294 queries in 1m0.013023948s
+Queries/sec: 4887.17
+Avg query latency: 3.408294ms
+P95 query latency: 10.965419ms
+P99 query latency: 19.184675ms
+RunConcurrentQueryStoreTest..
+
+=== Concurrent Query/Store Test ===
+Pre-populating database with 5000 events for concurrent query/store test...
+1763396542843038ℹ️ /tmp/benchmark_next-orly-badger_8: Block cache metrics: hit: 411640922 miss: 5406705 keys-added: 1627143 keys-updated: 3422501 keys-evicted: 1627125 cost-added: 84304242021549 cost-evicted: 84303233712402 sets-dropped: 0 sets-rejected: 295382 gets-dropped: 325582080 gets-kept: 91360192 gets-total: 417047650 hit-ratio: 0.99
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:454 /build/pkg/database/logger.go:56
+Concurrent test completed: 254899 operations (204899 queries, 50000 writes) in 1m0.006656731s
+Operations/sec: 4247.85
+Avg latency: 2.125728ms
+Avg query latency: 2.314927ms
+Avg write latency: 1.350394ms
+P95 latency: 3.778776ms
+P99 latency: 5.393909ms
+
+=== Test round completed ===
+
+
+================================================================================
+BENCHMARK REPORT
+================================================================================
+
+Test: Peak Throughput
+Duration: 5.666497805s
+Total Events: 50000
+Events/sec: 8823.79
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 257 MB
+Avg Latency: 2.020722ms
+P90 Latency: 2.645436ms
+P95 Latency: 2.995948ms
+P99 Latency: 4.460502ms
+Bottom 10% Avg Latency: 3.520179ms
+----------------------------------------
+
+Test: Burst Pattern
+Duration: 10.132858185s
+Total Events: 50000
+Events/sec: 4934.44
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 122 MB
+Avg Latency: 7.197024ms
+P90 Latency: 12.546513ms
+P95 Latency: 15.216454ms
+P99 Latency: 23.682573ms
+Bottom 10% Avg Latency: 18.172083ms
+----------------------------------------
+
+Test: Mixed Read/Write
+Duration: 24.625333257s
+Total Events: 50000
+Events/sec: 2030.43
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 120 MB
+Avg Latency: 467.389µs
+P90 Latency: 914.891µs
+P95 Latency: 1.0349ms
+P99 Latency: 1.268268ms
+Bottom 10% Avg Latency: 1.393626ms
+----------------------------------------
+
+Test: Query Performance
+Duration: 1m0.011972513s
+Total Events: 197562
+Events/sec: 3292.04
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 152 MB
+Avg Latency: 5.52205ms
+P90 Latency: 12.226879ms
+P95 Latency: 18.40165ms
+P99 Latency: 32.139723ms
+Bottom 10% Avg Latency: 20.985445ms
+----------------------------------------
+
+Test: Concurrent Query/Store
+Duration: 1m0.006047854s
+Total Events: 224870
+Events/sec: 3747.46
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 127 MB
+Avg Latency: 2.665369ms
+P90 Latency: 4.194993ms
+P95 Latency: 5.204253ms
+P99 Latency: 8.129537ms
+Bottom 10% Avg Latency: 5.884586ms
+----------------------------------------
+
+Test: Peak Throughput
+Duration: 5.145620568s
+Total Events: 50000
+Events/sec: 9717.00
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 522 MB
+Avg Latency: 1.788996ms
+P90 Latency: 2.241725ms
+P95 Latency: 2.442669ms
+P99 Latency: 3.110506ms
+Bottom 10% Avg Latency: 3.016821ms
+----------------------------------------
+
+Test: Burst Pattern
+Duration: 10.438224172s
+Total Events: 50000
+Events/sec: 4790.09
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 623 MB
+Avg Latency: 9.406859ms
+P90 Latency: 21.810715ms
+P95 Latency: 35.119382ms
+P99 Latency: 66.001509ms
+Bottom 10% Avg Latency: 39.782175ms
+----------------------------------------
+
+Test: Mixed Read/Write
+Duration: 24.485622359s
+Total Events: 50000
+Events/sec: 2042.01
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 165 MB
+Avg Latency: 445.318µs
+P90 Latency: 907.915µs
+P95 Latency: 1.021172ms
+P99 Latency: 1.227095ms
+Bottom 10% Avg Latency: 1.265835ms
+----------------------------------------
+
+Test: Query Performance
+Duration: 1m0.013023948s
+Total Events: 293294
+Events/sec: 4887.17
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 136 MB
+Avg Latency: 3.408294ms
+P90 Latency: 7.156129ms
+P95 Latency: 10.965419ms
+P99 Latency: 19.184675ms
+Bottom 10% Avg Latency: 12.469832ms
+----------------------------------------
+
+Test: Concurrent Query/Store
+Duration: 1m0.006656731s
+Total Events: 254899
+Events/sec: 4247.85
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 147 MB
+Avg Latency: 2.125728ms
+P90 Latency: 3.131901ms
+P95 Latency: 3.778776ms
+P99 Latency: 5.393909ms
+Bottom 10% Avg Latency: 4.22837ms
+----------------------------------------
+
+Report saved to: /tmp/benchmark_next-orly-badger_8/benchmark_report.txt
+AsciiDoc report saved to: /tmp/benchmark_next-orly-badger_8/benchmark_report.adoc
+1763396593981772ℹ️ /tmp/benchmark_next-orly-badger_8: Lifetime L0 stalled for: 0s
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:536 /build/pkg/database/logger.go:56
+1763396595378747ℹ️ /tmp/benchmark_next-orly-badger_8: 
+Level 0 [ ]: NumTables: 00. Size: 0 B of 0 B. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 1 [ ]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 2 [ ]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 3 [ ]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 4 [B]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 5 [ ]: NumTables: 01. Size: 94 MiB of 23 MiB. Score: 4.08->4.08 StaleData: 0 B Target FileSize: 122 MiB
+Level 6 [ ]: NumTables: 04. Size: 230 MiB of 230 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 244 MiB
+Level Done
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:615 /build/pkg/database/logger.go:56
+
+RELAY_NAME: next-orly-badger
+RELAY_URL: ws://next-orly-badger:8080
+TEST_TIMESTAMP: 2025-11-17T16:23:15+00:00
+BENCHMARK_CONFIG:
+  Events: 50000
+  Workers: 24
+  Duration: 60s
--- a/cmd/benchmark/reports/run_20251117_161622/next-orly-dgraph_results.txt
+++ b/cmd/benchmark/reports/run_20251117_161622/next-orly-dgraph_results.txt
@@ -0,0 +1,323 @@
+Starting Nostr Relay Benchmark
+Data Directory: /tmp/benchmark_next-orly-dgraph_8
+Events: 50000, Workers: 24, Duration: 1m0s
+1763396600574205ℹ️ /tmp/benchmark_next-orly-dgraph_8: All 0 tables opened in 0s
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/levels.go:161 /build/pkg/database/logger.go:56
+1763396600577795ℹ️ /tmp/benchmark_next-orly-dgraph_8: Discard stats nextEmptySlot: 0
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/discard.go:55 /build/pkg/database/logger.go:56
+1763396600577852ℹ️ /tmp/benchmark_next-orly-dgraph_8: Set nextTxnTs to 0
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:358 /build/pkg/database/logger.go:56
+1763396600578216ℹ️ migrating to version 1... /build/pkg/database/migrations.go:66
+1763396600578287ℹ️ migrating to version 2... /build/pkg/database/migrations.go:73
+1763396600578319ℹ️ migrating to version 3... /build/pkg/database/migrations.go:80
+1763396600578325ℹ️ cleaning up ephemeral events (kinds 20000-29999)... /build/pkg/database/migrations.go:287
+1763396600578334ℹ️ cleaned up 0 ephemeral events from database /build/pkg/database/migrations.go:332
+1763396600578350ℹ️ migrating to version 4... /build/pkg/database/migrations.go:87
+1763396600578355ℹ️ converting events to optimized inline storage (Reiser4 optimization)... /build/pkg/database/migrations.go:340
+1763396600578372ℹ️ found 0 events to convert (0 regular, 0 replaceable, 0 addressable) /build/pkg/database/migrations.go:429
+1763396600578378ℹ️ migration complete: converted 0 events to optimized inline storage, deleted 0 old keys /build/pkg/database/migrations.go:538
+
+=== Starting test round 1/2 ===
+RunPeakThroughputTest..
+
+=== Peak Throughput Test ===
+2025/11/17 16:23:20 INFO: Successfully loaded libsecp256k1 v5.0.0 from libsecp256k1.so.2
+1763396602578437ℹ️ /tmp/benchmark_next-orly-dgraph_8: database warmup complete, ready to serve requests
+/usr/local/go/src/runtime/asm_amd64.s:1693 /build/pkg/database/logger.go:56
+Events saved: 50000/50000 (100.0%)
+Duration: 4.932431923s
+Events/sec: 10136.99
+Avg latency: 1.667317ms
+P90 latency: 2.069461ms
+P95 latency: 2.249895ms
+P99 latency: 2.861303ms
+Bottom 10% Avg latency: 2.592597ms
+RunBurstPatternTest..
+
+=== Burst Pattern Test ===
+Burst completed: 5000 events in 335.655402ms
+Burst completed: 5000 events in 330.360552ms
+Burst completed: 5000 events in 350.90491ms
+Burst completed: 5000 events in 373.041958ms
+Burst completed: 5000 events in 347.11564ms
+Burst completed: 5000 events in 315.949199ms
+Burst completed: 5000 events in 331.42993ms
+Burst completed: 5000 events in 352.164361ms
+Burst completed: 5000 events in 359.115619ms
+Burst completed: 5000 events in 360.397544ms
+Burst test completed: 50000 events in 9.808342155s
+Events/sec: 5097.70
+RunMixedReadWriteTest..
+
+=== Mixed Read/Write Test ===
+Pre-populating database for read tests...
+Mixed test completed: 25000 writes, 25000 reads in 24.59623701s
+Combined ops/sec: 2032.83
+1763396660567060⚠️ /tmp/benchmark_next-orly-dgraph_8: Block cache might be too small. Metrics: hit: 153935 miss: 305257 keys-added: 227607 keys-updated: 64636 keys-evicted: 227588 cost-added: 12452581576986 cost-evicted: 12451583862757 sets-dropped: 0 sets-rejected: 12954 gets-dropped: 256 gets-kept: 458496 gets-total: 459192 hit-ratio: 0.34
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:450 /build/pkg/database/logger.go:46
+1763396660567121⚠️ /tmp/benchmark_next-orly-dgraph_8: Cache life expectancy (in seconds): 
+ -- Histogram: 
+Min value: 0 
+Max value: 11 
+Count: 227588 
+50p: 2.00 
+75p: 2.00 
+90p: 2.00 
+[0, 2) 227552 99.98% 99.98%
+[8, 16) 36 0.02% 100.00%
+ --
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:451 /build/pkg/database/logger.go:46
+RunQueryTest..
+
+=== Query Test ===
+Pre-populating database with 10000 events for query tests...
+Query test completed: 221626 queries in 1m0.014161671s
+Queries/sec: 3692.90
+Avg query latency: 4.849059ms
+P95 query latency: 15.966874ms
+P99 query latency: 27.859712ms
+RunConcurrentQueryStoreTest..
+
+=== Concurrent Query/Store Test ===
+Pre-populating database with 5000 events for concurrent query/store test...
+Concurrent test completed: 235023 operations (185023 queries, 50000 writes) in 1m0.005568823s
+Operations/sec: 3916.69
+Avg latency: 2.401379ms
+Avg query latency: 2.672573ms
+Avg write latency: 1.397837ms
+P95 latency: 4.398002ms
+P99 latency: 6.207183ms
+
+Pausing 10s before next round...
+
+=== Test round completed ===
+
+
+=== Starting test round 2/2 ===
+RunPeakThroughputTest..
+
+=== Peak Throughput Test ===
+Events saved: 50000/50000 (100.0%)
+Duration: 5.127096799s
+Events/sec: 9752.11
+Avg latency: 1.795821ms
+P90 latency: 2.25461ms
+P95 latency: 2.466785ms
+P99 latency: 3.159176ms
+Bottom 10% Avg latency: 3.072242ms
+RunBurstPatternTest..
+
+=== Burst Pattern Test ===
+Burst completed: 5000 events in 358.012209ms
+Burst completed: 5000 events in 336.300441ms
+Burst completed: 5000 events in 363.657063ms
+Burst completed: 5000 events in 356.771817ms
+Burst completed: 5000 events in 368.000986ms
+Burst completed: 5000 events in 441.821658ms
+Burst completed: 5000 events in 451.146122ms
+Burst completed: 5000 events in 455.159014ms
+Burst completed: 5000 events in 359.826504ms
+Burst completed: 5000 events in 358.602207ms
+1763396835570723ℹ️ /tmp/benchmark_next-orly-dgraph_8: [6] [E] LOG Compact 0->6 (8, 0 -> 4 tables with 1 splits). [00001 00002 00003 00004 00005 00006 00007 00008 . .] -> [00009 00010 00011 00012 .], took 3.055s
+, deleted 1901003 bytes
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/levels.go:1479 /build/pkg/database/logger.go:56
+Burst test completed: 50000 events in 10.25458455s
+Events/sec: 4875.87
+RunMixedReadWriteTest..
+
+=== Mixed Read/Write Test ===
+Pre-populating database for read tests...
+Mixed test completed: 25000 writes, 25000 reads in 24.474786024s
+Combined ops/sec: 2042.92
+RunQueryTest..
+
+=== Query Test ===
+Pre-populating database with 10000 events for query tests...
+Query test completed: 287727 queries in 1m0.012156857s
+Queries/sec: 4794.48
+Avg query latency: 3.504598ms
+P95 query latency: 11.416502ms
+P99 query latency: 19.871886ms
+RunConcurrentQueryStoreTest..
+
+=== Concurrent Query/Store Test ===
+Pre-populating database with 5000 events for concurrent query/store test...
+1763396960566384ℹ️ /tmp/benchmark_next-orly-dgraph_8: Block cache metrics: hit: 436764091 miss: 4871096 keys-added: 1584381 keys-updated: 2919606 keys-evicted: 1584361 cost-added: 83226283032882 cost-evicted: 83225259887553 sets-dropped: 0 sets-rejected: 305847 gets-dropped: 344794880 gets-kept: 96734656 gets-total: 441635219 hit-ratio: 0.99
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:454 /build/pkg/database/logger.go:56
+Concurrent test completed: 252209 operations (202209 queries, 50000 writes) in 1m0.008028818s
+Operations/sec: 4202.92
+Avg latency: 2.189461ms
+Avg query latency: 2.337704ms
+Avg write latency: 1.58994ms
+P95 latency: 3.919323ms
+P99 latency: 5.959314ms
+
+=== Test round completed ===
+
+
+================================================================================
+BENCHMARK REPORT
+================================================================================
+
+Test: Peak Throughput
+Duration: 4.932431923s
+Total Events: 50000
+Events/sec: 10136.99
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 432 MB
+Avg Latency: 1.667317ms
+P90 Latency: 2.069461ms
+P95 Latency: 2.249895ms
+P99 Latency: 2.861303ms
+Bottom 10% Avg Latency: 2.592597ms
+----------------------------------------
+
+Test: Burst Pattern
+Duration: 9.808342155s
+Total Events: 50000
+Events/sec: 5097.70
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 149 MB
+Avg Latency: 3.805495ms
+P90 Latency: 6.632151ms
+P95 Latency: 8.069195ms
+P99 Latency: 13.244195ms
+Bottom 10% Avg Latency: 9.922762ms
+----------------------------------------
+
+Test: Mixed Read/Write
+Duration: 24.59623701s
+Total Events: 50000
+Events/sec: 2032.83
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 121 MB
+Avg Latency: 467.746µs
+P90 Latency: 911.189µs
+P95 Latency: 1.018554ms
+P99 Latency: 1.250848ms
+Bottom 10% Avg Latency: 1.345857ms
+----------------------------------------
+
+Test: Query Performance
+Duration: 1m0.014161671s
+Total Events: 221626
+Events/sec: 3692.90
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 125 MB
+Avg Latency: 4.849059ms
+P90 Latency: 10.564822ms
+P95 Latency: 15.966874ms
+P99 Latency: 27.859712ms
+Bottom 10% Avg Latency: 18.180391ms
+----------------------------------------
+
+Test: Concurrent Query/Store
+Duration: 1m0.005568823s
+Total Events: 235023
+Events/sec: 3916.69
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 177 MB
+Avg Latency: 2.401379ms
+P90 Latency: 3.659643ms
+P95 Latency: 4.398002ms
+P99 Latency: 6.207183ms
+Bottom 10% Avg Latency: 4.857955ms
+----------------------------------------
+
+Test: Peak Throughput
+Duration: 5.127096799s
+Total Events: 50000
+Events/sec: 9752.11
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 480 MB
+Avg Latency: 1.795821ms
+P90 Latency: 2.25461ms
+P95 Latency: 2.466785ms
+P99 Latency: 3.159176ms
+Bottom 10% Avg Latency: 3.072242ms
+----------------------------------------
+
+Test: Burst Pattern
+Duration: 10.25458455s
+Total Events: 50000
+Events/sec: 4875.87
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 621 MB
+Avg Latency: 9.266976ms
+P90 Latency: 24.12544ms
+P95 Latency: 34.465042ms
+P99 Latency: 55.446215ms
+Bottom 10% Avg Latency: 37.317916ms
+----------------------------------------
+
+Test: Mixed Read/Write
+Duration: 24.474786024s
+Total Events: 50000
+Events/sec: 2042.92
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 182 MB
+Avg Latency: 452.46µs
+P90 Latency: 909.806µs
+P95 Latency: 1.014516ms
+P99 Latency: 1.214797ms
+Bottom 10% Avg Latency: 1.304994ms
+----------------------------------------
+
+Test: Query Performance
+Duration: 1m0.012156857s
+Total Events: 287727
+Events/sec: 4794.48
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 150 MB
+Avg Latency: 3.504598ms
+P90 Latency: 7.480817ms
+P95 Latency: 11.416502ms
+P99 Latency: 19.871886ms
+Bottom 10% Avg Latency: 12.934864ms
+----------------------------------------
+
+Test: Concurrent Query/Store
+Duration: 1m0.008028818s
+Total Events: 252209
+Events/sec: 4202.92
+Success Rate: 100.0%
+Concurrent Workers: 24
+Memory Used: 98 MB
+Avg Latency: 2.189461ms
+P90 Latency: 3.213337ms
+P95 Latency: 3.919323ms
+P99 Latency: 5.959314ms
+Bottom 10% Avg Latency: 4.521426ms
+----------------------------------------
+
+Report saved to: /tmp/benchmark_next-orly-dgraph_8/benchmark_report.txt
+AsciiDoc report saved to: /tmp/benchmark_next-orly-dgraph_8/benchmark_report.adoc
+1763397010410098ℹ️ /tmp/benchmark_next-orly-dgraph_8: Lifetime L0 stalled for: 0s
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:536 /build/pkg/database/logger.go:56
+1763397011943178ℹ️ /tmp/benchmark_next-orly-dgraph_8: 
+Level 0 [ ]: NumTables: 00. Size: 0 B of 0 B. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 1 [ ]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 2 [ ]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 3 [ ]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 4 [B]: NumTables: 00. Size: 0 B of 10 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 61 MiB
+Level 5 [ ]: NumTables: 01. Size: 94 MiB of 23 MiB. Score: 4.08->4.08 StaleData: 0 B Target FileSize: 122 MiB
+Level 6 [ ]: NumTables: 04. Size: 230 MiB of 230 MiB. Score: 0.00->0.00 StaleData: 0 B Target FileSize: 244 MiB
+Level Done
+/go/pkg/mod/github.com/dgraph-io/badger/v4@v4.8.0/db.go:615 /build/pkg/database/logger.go:56
+
+RELAY_NAME: next-orly-dgraph
+RELAY_URL: ws://next-orly-dgraph:8080
+TEST_TIMESTAMP: 2025-11-17T16:30:12+00:00
+BENCHMARK_CONFIG:
+  Events: 50000
+  Workers: 24
+  Duration: 60s
--- a/cmd/benchmark/run-badger-benchmark.sh
+++ b/cmd/benchmark/run-badger-benchmark.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+# Run Badger benchmark with reduced cache sizes to avoid OOM
+
+# Set reasonable cache sizes for benchmark
+export ORLY_DB_BLOCK_CACHE_MB=256   # Reduced from 1024MB
+export ORLY_DB_INDEX_CACHE_MB=128   # Reduced from 512MB
+export ORLY_QUERY_CACHE_SIZE_MB=128 # Reduced from 512MB
+
+# Clean up old data
+rm -rf /tmp/benchmark_db_badger
+
+echo "Running Badger benchmark with reduced cache sizes:"
+echo "  Block Cache: ${ORLY_DB_BLOCK_CACHE_MB}MB"
+echo "  Index Cache: ${ORLY_DB_INDEX_CACHE_MB}MB"
+echo "  Query Cache: ${ORLY_QUERY_CACHE_SIZE_MB}MB"
+echo ""
+
+# Run benchmark
+./benchmark -events "${1:-1000}" -workers "${2:-4}" -datadir /tmp/benchmark_db_badger
--- a/cmd/benchmark/run-benchmark.sh
+++ b/cmd/benchmark/run-benchmark.sh
@@ -31,8 +31,8 @@ fi

 # Create fresh data directories with correct permissions
 echo "Preparing data directories..."
-mkdir -p data/{next-orly,khatru-sqlite,khatru-badger,relayer-basic,strfry,nostr-rs-relay,postgres}
-chmod 777 data/{next-orly,khatru-sqlite,khatru-badger,relayer-basic,strfry,nostr-rs-relay,postgres}
+mkdir -p data/{next-orly-badger,next-orly-dgraph,dgraph-zero,dgraph-alpha,khatru-sqlite,khatru-badger,relayer-basic,strfry,nostr-rs-relay,postgres}
+chmod 777 data/{next-orly-badger,next-orly-dgraph,dgraph-zero,dgraph-alpha,khatru-sqlite,khatru-badger,relayer-basic,strfry,nostr-rs-relay,postgres}

 echo "Starting benchmark suite..."
 echo "This will automatically shut down all containers when the benchmark completes."
--- a/docs/NEO4J_BACKEND.md
+++ b/docs/NEO4J_BACKEND.md
@@ -0,0 +1,406 @@
+# Neo4j Database Backend for ORLY Relay
+
+## Overview
+
+The Neo4j database backend provides a graph-native storage solution for the ORLY Nostr relay. Unlike traditional key-value or document stores, Neo4j is optimized for relationship-heavy queries, making it an ideal fit for Nostr's social graph and event reference patterns.
+
+## Architecture
+
+### Core Components
+
+1. **Main Database File** ([pkg/neo4j/neo4j.go](../pkg/neo4j/neo4j.go))
+   - Implements the `database.Database` interface
+   - Manages Neo4j driver connection and lifecycle
+   - Uses Badger for metadata storage (markers, identity, subscriptions)
+   - Registers with the database factory via `init()`
+
+2. **Schema Management** ([pkg/neo4j/schema.go](../pkg/neo4j/schema.go))
+   - Defines Neo4j constraints and indexes using Cypher
+   - Creates unique constraints on Event IDs and Author pubkeys
+   - Indexes for optimal query performance (kind, created_at, tags)
+
+3. **Query Engine** ([pkg/neo4j/query-events.go](../pkg/neo4j/query-events.go))
+   - Translates Nostr REQ filters to Cypher queries
+   - Leverages graph traversal for tag relationships
+   - Supports prefix matching for IDs and pubkeys
+   - Parameterized queries for security and performance
+
+4. **Event Storage** ([pkg/neo4j/save-event.go](../pkg/neo4j/save-event.go))
+   - Stores events as nodes with properties
+   - Creates graph relationships:
+     - `AUTHORED_BY`: Event → Author
+     - `REFERENCES`: Event → Event (e-tags)
+     - `MENTIONS`: Event → Author (p-tags)
+     - `TAGGED_WITH`: Event → Tag
+
+## Graph Schema
+
+### Node Types
+
+**Event Node**
+```cypher
+(:Event {
+  id: string,           // Hex-encoded event ID (32 bytes)
+  serial: int,          // Sequential serial number
+  kind: int,            // Event kind
+  created_at: int,      // Unix timestamp
+  content: string,      // Event content
+  sig: string,          // Hex-encoded signature
+  pubkey: string,       // Hex-encoded author pubkey
+  tags: string          // JSON-encoded tags array
+})
+```
+
+**Author Node**
+```cypher
+(:Author {
+  pubkey: string        // Hex-encoded pubkey (unique)
+})
+```
+
+**Tag Node**
+```cypher
+(:Tag {
+  type: string,         // Tag type (e.g., "t", "d")
+  value: string         // Tag value
+})
+```
+
+**Marker Node** (for metadata)
+```cypher
+(:Marker {
+  key: string,          // Unique key
+  value: string         // Hex-encoded value
+})
+```
+
+### Relationships
+
+- `(:Event)-[:AUTHORED_BY]->(:Author)` - Event authorship
+- `(:Event)-[:REFERENCES]->(:Event)` - Event references (e-tags)
+- `(:Event)-[:MENTIONS]->(:Author)` - Author mentions (p-tags)
+- `(:Event)-[:TAGGED_WITH]->(:Tag)` - Generic tag associations
+
+## How Nostr REQ Messages Are Implemented
+
+### Filter to Cypher Translation
+
+The query engine in [query-events.go](../pkg/neo4j/query-events.go) translates Nostr filters to Cypher queries:
+
+#### 1. ID Filters
+```json
+{"ids": ["abc123..."]}
+```
+Becomes:
+```cypher
+MATCH (e:Event)
+WHERE e.id = $id_0
+```
+
+For prefix matching (partial IDs):
+```cypher
+WHERE e.id STARTS WITH $id_0
+```
+
+#### 2. Author Filters
+```json
+{"authors": ["pubkey1...", "pubkey2..."]}
+```
+Becomes:
+```cypher
+MATCH (e:Event)
+WHERE e.pubkey IN $authors
+```
+
+#### 3. Kind Filters
+```json
+{"kinds": [1, 7]}
+```
+Becomes:
+```cypher
+MATCH (e:Event)
+WHERE e.kind IN $kinds
+```
+
+#### 4. Time Range Filters
+```json
+{"since": 1234567890, "until": 1234567900}
+```
+Becomes:
+```cypher
+MATCH (e:Event)
+WHERE e.created_at >= $since AND e.created_at <= $until
+```
+
+#### 5. Tag Filters (Graph Advantage!)
+```json
+{"#t": ["bitcoin", "nostr"]}
+```
+Becomes:
+```cypher
+MATCH (e:Event)
+OPTIONAL MATCH (e)-[:TAGGED_WITH]->(t0:Tag)
+WHERE t0.type = $tagType_0 AND t0.value IN $tagValues_0
+```
+
+This leverages Neo4j's native graph traversal for efficient tag queries!
+
+#### 6. Combined Filters
+```json
+{
+  "kinds": [1],
+  "authors": ["abc..."],
+  "#p": ["xyz..."],
+  "limit": 50
+}
+```
+Becomes:
+```cypher
+MATCH (e:Event)
+OPTIONAL MATCH (e)-[:TAGGED_WITH]->(t0:Tag)
+WHERE e.kind IN $kinds
+  AND e.pubkey IN $authors
+  AND t0.type = $tagType_0
+  AND t0.value IN $tagValues_0
+RETURN e.id, e.kind, e.created_at, e.content, e.sig, e.pubkey, e.tags
+ORDER BY e.created_at DESC
+LIMIT $limit
+```
+
+### Query Execution Flow
+
+1. **Parse Filter**: Extract IDs, authors, kinds, times, tags
+2. **Build Cypher**: Construct parameterized query with MATCH/WHERE clauses
+3. **Execute**: Run via `ExecuteRead()` with read-only session
+4. **Parse Results**: Convert Neo4j records to Nostr events
+5. **Return**: Send events back to client
+
+## Configuration
+
+### Environment Variables
+
+```bash
+# Neo4j Connection
+ORLY_NEO4J_URI="bolt://localhost:7687"
+ORLY_NEO4J_USER="neo4j"
+ORLY_NEO4J_PASSWORD="password"
+
+# Database Type Selection
+ORLY_DB_TYPE="neo4j"
+
+# Data Directory (for Badger metadata storage)
+ORLY_DATA_DIR="~/.local/share/ORLY"
+```
+
+### Example Docker Compose Setup
+
+```yaml
+version: '3.8'
+services:
+  neo4j:
+    image: neo4j:5.15
+    ports:
+      - "7474:7474"  # HTTP
+      - "7687:7687"  # Bolt
+    environment:
+      - NEO4J_AUTH=neo4j/password
+      - NEO4J_PLUGINS=["apoc"]
+    volumes:
+      - neo4j_data:/data
+      - neo4j_logs:/logs
+
+  orly:
+    build: .
+    ports:
+      - "3334:3334"
+    environment:
+      - ORLY_DB_TYPE=neo4j
+      - ORLY_NEO4J_URI=bolt://neo4j:7687
+      - ORLY_NEO4J_USER=neo4j
+      - ORLY_NEO4J_PASSWORD=password
+    depends_on:
+      - neo4j
+
+volumes:
+  neo4j_data:
+  neo4j_logs:
+```
+
+## Performance Considerations
+
+### Advantages Over Badger/DGraph
+
+1. **Native Graph Queries**: Tag relationships and social graph traversals are native operations
+2. **Optimized Indexes**: Automatic index usage for constrained properties
+3. **Efficient Joins**: Relationship traversals are O(1) lookups
+4. **Query Planner**: Neo4j's query planner optimizes complex multi-filter queries
+
+### Tuning Recommendations
+
+1. **Indexes**: The schema creates indexes for:
+   - Event ID (unique constraint + index)
+   - Event kind
+   - Event created_at
+   - Composite: kind + created_at
+   - Tag type + value
+
+2. **Cache Configuration**: Configure Neo4j's page cache and heap size:
+```conf
+# neo4j.conf
+dbms.memory.heap.initial_size=2G
+dbms.memory.heap.max_size=4G
+dbms.memory.pagecache.size=4G
+```
+
+3. **Query Limits**: Always use LIMIT in queries to prevent memory exhaustion
+
+## Implementation Details
+
+### Replaceable Events
+
+Replaceable events (kinds 0, 3, 10000-19999) are handled in `WouldReplaceEvent()`:
+
+```cypher
+MATCH (e:Event {kind: $kind, pubkey: $pubkey})
+WHERE e.created_at < $createdAt
+RETURN e.serial, e.created_at
+```
+
+Older events are deleted before saving the new one.
+
+### Parameterized Replaceable Events
+
+For kinds 30000-39999, we also match on the d-tag:
+
+```cypher
+MATCH (e:Event {kind: $kind, pubkey: $pubkey})-[:TAGGED_WITH]->(t:Tag {type: 'd', value: $dValue})
+WHERE e.created_at < $createdAt
+RETURN e.serial
+```
+
+### Event Deletion (NIP-09)
+
+Delete events (kind 5) are processed via graph traversal:
+
+```cypher
+MATCH (target:Event {id: $targetId})
+MATCH (delete:Event {kind: 5})-[:REFERENCES]->(target)
+WHERE delete.pubkey = $pubkey OR delete.pubkey IN $admins
+RETURN delete.id
+```
+
+Only same-author or admin deletions are allowed.
+
+## Comparison with Other Backends
+
+| Feature | Badger | DGraph | Neo4j |
+|---------|--------|--------|-------|
+| **Storage Type** | Key-value | Graph (distributed) | Graph (native) |
+| **Query Language** | Custom indexes | DQL | Cypher |
+| **Tag Queries** | Index lookups | Graph traversal | Native relationships |
+| **Scaling** | Single-node | Distributed | Cluster/Causal cluster |
+| **Memory Usage** | Low | Medium | High |
+| **Setup Complexity** | Minimal | Medium | Medium |
+| **Best For** | Small relays | Large distributed | Relationship-heavy |
+
+## Development Guide
+
+### Adding New Indexes
+
+1. Update [schema.go](../pkg/neo4j/schema.go) with new index definition
+2. Add to `applySchema()` function
+3. Restart relay to apply schema changes
+
+Example:
+```cypher
+CREATE INDEX event_content_fulltext IF NOT EXISTS
+FOR (e:Event) ON (e.content)
+OPTIONS {indexConfig: {`fulltext.analyzer`: 'english'}}
+```
+
+### Custom Queries
+
+To add custom query methods:
+
+1. Add method to [query-events.go](../pkg/neo4j/query-events.go)
+2. Build Cypher query with parameterization
+3. Use `ExecuteRead()` or `ExecuteWrite()` as appropriate
+4. Parse results with `parseEventsFromResult()`
+
+### Testing
+
+Due to Neo4j dependency, tests require a running Neo4j instance:
+
+```bash
+# Start Neo4j via Docker
+docker run -d --name neo4j-test \
+  -p 7687:7687 \
+  -e NEO4J_AUTH=neo4j/test \
+  neo4j:5.15
+
+# Run tests
+ORLY_NEO4J_URI="bolt://localhost:7687" \
+ORLY_NEO4J_USER="neo4j" \
+ORLY_NEO4J_PASSWORD="test" \
+go test ./pkg/neo4j/...
+
+# Cleanup
+docker rm -f neo4j-test
+```
+
+## Future Enhancements
+
+1. **Full-text Search**: Leverage Neo4j's full-text indexes for content search
+2. **Graph Analytics**: Implement social graph metrics (centrality, communities)
+3. **Advanced Queries**: Support NIP-50 search via Cypher full-text capabilities
+4. **Clustering**: Deploy Neo4j cluster for high availability
+5. **APOC Procedures**: Utilize APOC library for advanced graph algorithms
+6. **Caching Layer**: Implement query result caching similar to Badger backend
+
+## Troubleshooting
+
+### Connection Issues
+
+```bash
+# Test connectivity
+cypher-shell -a bolt://localhost:7687 -u neo4j -p password
+
+# Check Neo4j logs
+docker logs neo4j
+```
+
+### Performance Issues
+
+```cypher
+// View query execution plan
+EXPLAIN MATCH (e:Event) WHERE e.kind = 1 RETURN e LIMIT 10
+
+// Profile query performance
+PROFILE MATCH (e:Event)-[:AUTHORED_BY]->(a:Author) RETURN e, a LIMIT 10
+```
+
+### Schema Issues
+
+```cypher
+// List all constraints
+SHOW CONSTRAINTS
+
+// List all indexes
+SHOW INDEXES
+
+// Drop and recreate schema
+DROP CONSTRAINT event_id_unique IF EXISTS
+CREATE CONSTRAINT event_id_unique FOR (e:Event) REQUIRE e.id IS UNIQUE
+```
+
+## References
+
+- [Neo4j Documentation](https://neo4j.com/docs/)
+- [Cypher Query Language](https://neo4j.com/docs/cypher-manual/current/)
+- [Neo4j Go Driver](https://neo4j.com/docs/go-manual/current/)
+- [Graph Database Patterns](https://neo4j.com/developer/graph-db-vs-rdbms/)
+- [Nostr Protocol (NIP-01)](https://github.com/nostr-protocol/nips/blob/master/01.md)
+
+## License
+
+This Neo4j backend implementation follows the same license as the ORLY relay project.
--- a/go.mod
+++ b/go.mod
@@ -41,6 +41,7 @@ require (
 	github.com/google/pprof v0.0.0-20251007162407-5df77e3f7d1d // indirect
 	github.com/klauspost/compress v1.18.1 // indirect
 	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
+	github.com/neo4j/neo4j-go-driver/v5 v5.28.4 // indirect
 	github.com/pkg/errors v0.8.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/templexxx/cpu v0.1.1 // indirect
--- a/go.sum
+++ b/go.sum
@@ -94,6 +94,8 @@ github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1
 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM=
 github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8=
+github.com/neo4j/neo4j-go-driver/v5 v5.28.4 h1:7toxehVcYkZbyxV4W3Ib9VcnyRBQPucF+VwNNmtSXi4=
+github.com/neo4j/neo4j-go-driver/v5 v5.28.4/go.mod h1:Vff8OwT7QpLm7L2yYr85XNWe9Rbqlbeb9asNXJTHO4k=
 github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
 github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
--- a/main.go
+++ b/main.go
@@ -22,6 +22,7 @@ import (
 	"next.orly.dev/pkg/crypto/keys"
 	"next.orly.dev/pkg/database"
 	_ "next.orly.dev/pkg/dgraph" // Import to register dgraph factory
+	_ "next.orly.dev/pkg/neo4j"  // Import to register neo4j factory
 	"next.orly.dev/pkg/encoders/hex"
 	"next.orly.dev/pkg/utils/interrupt"
 	"next.orly.dev/pkg/version"
--- a/pkg/database/factory.go
+++ b/pkg/database/factory.go
@@ -7,7 +7,7 @@ import (
 )

 // NewDatabase creates a database instance based on the specified type.
-// Supported types: "badger", "dgraph"
+// Supported types: "badger", "dgraph", "neo4j"
 func NewDatabase(
 	ctx context.Context,
 	cancel context.CancelFunc,
@@ -23,8 +23,12 @@ func NewDatabase(
 		// Use the new dgraph implementation
 		// Import dynamically to avoid import cycles
 		return newDgraphDatabase(ctx, cancel, dataDir, logLevel)
+	case "neo4j":
+		// Use the new neo4j implementation
+		// Import dynamically to avoid import cycles
+		return newNeo4jDatabase(ctx, cancel, dataDir, logLevel)
 	default:
-		return nil, fmt.Errorf("unsupported database type: %s (supported: badger, dgraph)", dbType)
+		return nil, fmt.Errorf("unsupported database type: %s (supported: badger, dgraph, neo4j)", dbType)
 	}
 }

@@ -37,3 +41,13 @@ var newDgraphDatabase func(context.Context, context.CancelFunc, string, string)
 func RegisterDgraphFactory(factory func(context.Context, context.CancelFunc, string, string) (Database, error)) {
 	newDgraphDatabase = factory
 }
+
+// newNeo4jDatabase creates a neo4j database instance
+// This is defined here to avoid import cycles
+var newNeo4jDatabase func(context.Context, context.CancelFunc, string, string) (Database, error)
+
+// RegisterNeo4jFactory registers the neo4j database factory
+// This is called from the neo4j package's init() function
+func RegisterNeo4jFactory(factory func(context.Context, context.CancelFunc, string, string) (Database, error)) {
+	newNeo4jDatabase = factory
+}
--- a/pkg/database/get-serial-by-id.go
+++ b/pkg/database/get-serial-by-id.go
@@ -10,12 +10,12 @@ import (
 	"next.orly.dev/pkg/database/indexes/types"
 	"next.orly.dev/pkg/encoders/event"
 	"next.orly.dev/pkg/encoders/filter"
-	"next.orly.dev/pkg/encoders/hex"
+	// "next.orly.dev/pkg/encoders/hex"
 	"next.orly.dev/pkg/encoders/tag"
 )

 func (d *D) GetSerialById(id []byte) (ser *types.Uint40, err error) {
-	log.T.F("GetSerialById: input id=%s", hex.Enc(id))
+	// log.T.F("GetSerialById: input id=%s", hex.Enc(id))
 	var idxs []Range
 	if idxs, err = GetIndexesFromFilter(&filter.F{Ids: tag.NewFromBytesSlice(id)}); chk.E(err) {
 		return
@@ -58,7 +58,7 @@ func (d *D) GetSerialById(id []byte) (ser *types.Uint40, err error) {
 		return
 	}
 	if !idFound {
-		err = errorf.T("id not found in database: %s", hex.Enc(id))
+		// err = errorf.T("id not found in database: %s", hex.Enc(id))
 		return
 	}

@@ -80,7 +80,7 @@ func (d *D) GetSerialsByIds(ids *tag.T) (
 func (d *D) GetSerialsByIdsWithFilter(
 	ids *tag.T, fn func(ev *event.E, ser *types.Uint40) bool,
 ) (serials map[string]*types.Uint40, err error) {
-	log.T.F("GetSerialsByIdsWithFilter: input ids count=%d", ids.Len())
+	// log.T.F("GetSerialsByIdsWithFilter: input ids count=%d", ids.Len())

 	// Initialize the result map with estimated capacity to reduce reallocations
 	serials = make(map[string]*types.Uint40, ids.Len())
--- a/pkg/database/get-serials-by-range.go
+++ b/pkg/database/get-serials-by-range.go
@@ -33,7 +33,7 @@ func (d *D) GetSerialsByRange(idx Range) (
 			}
 			iterCount := 0
 			it.Seek(endBoundary)
-			log.T.F("GetSerialsByRange: iterator valid=%v, sought to endBoundary", it.Valid())
+			// log.T.F("GetSerialsByRange: iterator valid=%v, sought to endBoundary", it.Valid())
 			for it.Valid() {
 				iterCount++
 				if iterCount > 100 {
@@ -46,12 +46,12 @@ func (d *D) GetSerialsByRange(idx Range) (
 				key = item.Key()
 				keyWithoutSerial := key[:len(key)-5]
 				cmp := bytes.Compare(keyWithoutSerial, idx.Start)
-				log.T.F("GetSerialsByRange: iter %d, key prefix matches=%v, cmp=%d", iterCount, bytes.HasPrefix(key, idx.Start[:len(idx.Start)-8]), cmp)
+				// log.T.F("GetSerialsByRange: iter %d, key prefix matches=%v, cmp=%d", iterCount, bytes.HasPrefix(key, idx.Start[:len(idx.Start)-8]), cmp)
 				if cmp < 0 {
 					// didn't find it within the timestamp range
-					log.T.F("GetSerialsByRange: key out of range (cmp=%d), stopping iteration", cmp)
-					log.T.F("  keyWithoutSerial len=%d: %x", len(keyWithoutSerial), keyWithoutSerial)
-					log.T.F("  idx.Start len=%d: %x", len(idx.Start), idx.Start)
+					// log.T.F("GetSerialsByRange: key out of range (cmp=%d), stopping iteration", cmp)
+					// log.T.F("  keyWithoutSerial len=%d: %x", len(keyWithoutSerial), keyWithoutSerial)
+					// log.T.F("  idx.Start len=%d: %x", len(idx.Start), idx.Start)
 					return
 				}
 				ser := new(types.Uint40)
@@ -62,7 +62,7 @@ func (d *D) GetSerialsByRange(idx Range) (
 				sers = append(sers, ser)
 				it.Next()
 			}
-			log.T.F("GetSerialsByRange: iteration complete, found %d serials", len(sers))
+			// log.T.F("GetSerialsByRange: iteration complete, found %d serials", len(sers))
 			return
 		},
 	); chk.E(err) {
--- a/pkg/database/query-for-deleted.go
+++ b/pkg/database/query-for-deleted.go
@@ -5,7 +5,6 @@ import (

 	"lol.mleku.dev/chk"
 	"lol.mleku.dev/errorf"
-	"lol.mleku.dev/log"
 	"next.orly.dev/pkg/database/indexes/types"
 	"next.orly.dev/pkg/encoders/event"
 	"next.orly.dev/pkg/encoders/filter"
@@ -21,7 +20,7 @@ import (
 // pubkeys that also may delete the event, normally only the author is allowed
 // to delete an event.
 func (d *D) CheckForDeleted(ev *event.E, admins [][]byte) (err error) {
-	log.T.F("CheckForDeleted: checking event %x", ev.ID)
+	// log.T.F("CheckForDeleted: checking event %x", ev.ID)
 	keys := append([][]byte{ev.Pubkey}, admins...)
 	authors := tag.NewFromBytesSlice(keys...)
 	// if the event is addressable, check for a deletion event with the same
@@ -186,9 +185,9 @@ func (d *D) CheckForDeleted(ev *event.E, admins [][]byte) (err error) {
 		return
 	}
 	// otherwise we check for a delete by event id
-	log.T.F("CheckForDeleted: checking for e-tag deletion of event %x", ev.ID)
-	log.T.F("CheckForDeleted: authors filter: %v", authors)
-	log.T.F("CheckForDeleted: looking for tag e with value: %s", hex.Enc(ev.ID))
+	// log.T.F("CheckForDeleted: checking for e-tag deletion of event %x", ev.ID)
+	// log.T.F("CheckForDeleted: authors filter: %v", authors)
+	// log.T.F("CheckForDeleted: looking for tag e with value: %s", hex.Enc(ev.ID))
 	var idxs []Range
 	if idxs, err = GetIndexesFromFilter(
 		&filter.F{
@@ -201,18 +200,18 @@ func (d *D) CheckForDeleted(ev *event.E, admins [][]byte) (err error) {
 	); chk.E(err) {
 		return
 	}
-	log.T.F("CheckForDeleted: found %d indexes", len(idxs))
+	// log.T.F("CheckForDeleted: found %d indexes", len(idxs))
 	var sers types.Uint40s
-	for i, idx := range idxs {
-		log.T.F("CheckForDeleted: checking index %d: %v", i, idx)
+	for _, idx := range idxs {
+		// log.T.F("CheckForDeleted: checking index %d: %v", i, idx)
 		var s types.Uint40s
 		if s, err = d.GetSerialsByRange(idx); chk.E(err) {
 			return
 		}
-		log.T.F("CheckForDeleted: index %d returned %d serials", i, len(s))
+		// log.T.F("CheckForDeleted: index %d returned %d serials", i, len(s))
 		if len(s) > 0 {
 			// Any e-tag deletion found means the exact event was deleted and cannot be resubmitted
-			log.T.F("CheckForDeleted: found e-tag deletion for event %x", ev.ID)
+			// log.T.F("CheckForDeleted: found e-tag deletion for event %x", ev.ID)
 			err = errorf.E("blocked: %0x has been deleted", ev.ID)
 			return
 		}
--- a/pkg/database/save-event.go
+++ b/pkg/database/save-event.go
@@ -180,10 +180,10 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 	if idxs, err = GetIndexesForEvent(ev, serial); chk.E(err) {
 		return
 	}
-	log.T.F(
-		"SaveEvent: generated %d indexes for event %x (kind %d)", len(idxs),
-		ev.ID, ev.Kind,
-	)
+	// log.T.F(
+	// 	"SaveEvent: generated %d indexes for event %x (kind %d)", len(idxs),
+	// 	ev.ID, ev.Kind,
+	// )

 	// Serialize event once to check size
 	eventDataBuf := new(bytes.Buffer)
@@ -247,10 +247,10 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 				if err = txn.Set(keyBuf.Bytes(), nil); chk.E(err) {
 					return
 				}
-				log.T.F(
-					"SaveEvent: stored small event inline (%d bytes)",
-					len(eventData),
-				)
+				// log.T.F(
+				// 	"SaveEvent: stored small event inline (%d bytes)",
+				// 	len(eventData),
+				// )
 			} else {
 				// Large event: store separately with evt prefix
 				keyBuf := new(bytes.Buffer)
@@ -260,10 +260,10 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 				if err = txn.Set(keyBuf.Bytes(), eventData); chk.E(err) {
 					return
 				}
-				log.T.F(
-					"SaveEvent: stored large event separately (%d bytes)",
-					len(eventData),
-				)
+				// log.T.F(
+				// "SaveEvent: stored large event separately (%d bytes)",
+				// len(eventData),
+				// )
 			}

 			// Additionally, store replaceable/addressable events with specialized keys for direct access
@@ -293,7 +293,7 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 				if err = txn.Set(keyBuf.Bytes(), nil); chk.E(err) {
 					return
 				}
-				log.T.F("SaveEvent: also stored addressable event with specialized key")
+				// log.T.F("SaveEvent: also stored addressable event with specialized key")
 			} else if isReplaceableEvent && isSmallEvent {
 				// Replaceable event: also store with rev|pubkey_hash|kind|size|data
 				pubHash := new(types.PubHash)
@@ -340,7 +340,7 @@ func (d *D) SaveEvent(c context.Context, ev *event.E) (
 	// This ensures subsequent queries will see the new event
 	if d.queryCache != nil {
 		d.queryCache.Invalidate()
-		log.T.F("SaveEvent: invalidated query cache")
+		// log.T.F("SaveEvent: invalidated query cache")
 	}

 	return
--- a/pkg/dgraph/delete.go
+++ b/pkg/dgraph/delete.go
@@ -2,7 +2,9 @@ package dgraph

 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"time"

 	"github.com/dgraph-io/dgo/v230/protos/api"
 	"next.orly.dev/pkg/database/indexes/types"
@@ -98,13 +100,83 @@ func (d *D) DeleteEventBySerial(c context.Context, ser *types.Uint40, ev *event.
 	return nil
 }

-// DeleteExpired removes events that have passed their expiration time
+// DeleteExpired removes events that have passed their expiration time (NIP-40)
 func (d *D) DeleteExpired() {
-	// Query for events with expiration tags
-	// This is a stub - full implementation would:
-	// 1. Find events with "expiration" tag
-	// 2. Check if current time > expiration time
-	// 3. Delete those events
+	// Query for events that have an "expiration" tag
+	// NIP-40: events should have a tag ["expiration", "<unix timestamp>"]
+	query := `{
+		events(func: has(event.tags)) {
+			uid
+			event.id
+			event.tags
+			event.created_at
+		}
+	}`
+
+	resp, err := d.Query(context.Background(), query)
+	if err != nil {
+		d.Logger.Errorf("failed to query events for expiration: %v", err)
+		return
+	}
+
+	var result struct {
+		Events []struct {
+			UID       string `json:"uid"`
+			ID        string `json:"event.id"`
+			Tags      string `json:"event.tags"`
+			CreatedAt int64  `json:"event.created_at"`
+		} `json:"events"`
+	}
+
+	if err = unmarshalJSON(resp.Json, &result); err != nil {
+		d.Logger.Errorf("failed to parse events for expiration: %v", err)
+		return
+	}
+
+	now := time.Now().Unix()
+	deletedCount := 0
+
+	for _, ev := range result.Events {
+		// Parse tags
+		if ev.Tags == "" {
+			continue
+		}
+
+		var tags [][]string
+		if err := json.Unmarshal([]byte(ev.Tags), &tags); err != nil {
+			continue
+		}
+
+		// Look for expiration tag
+		var expirationTime int64
+		for _, tag := range tags {
+			if len(tag) >= 2 && tag[0] == "expiration" {
+				// Parse expiration timestamp
+				if _, err := fmt.Sscanf(tag[1], "%d", &expirationTime); err != nil {
+					continue
+				}
+				break
+			}
+		}
+
+		// If expiration time found and passed, delete the event
+		if expirationTime > 0 && now > expirationTime {
+			mutation := &api.Mutation{
+				DelNquads: []byte(fmt.Sprintf("<%s> * * .", ev.UID)),
+				CommitNow: true,
+			}
+
+			if _, err := d.Mutate(context.Background(), mutation); err != nil {
+				d.Logger.Warningf("failed to delete expired event %s: %v", ev.ID, err)
+			} else {
+				deletedCount++
+			}
+		}
+	}
+
+	if deletedCount > 0 {
+		d.Logger.Infof("deleted %d expired events", deletedCount)
+	}
 }

 // ProcessDelete processes a kind 5 deletion event
--- a/pkg/dgraph/dgraph.go
+++ b/pkg/dgraph/dgraph.go
@@ -4,6 +4,7 @@ package dgraph

 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -12,11 +13,11 @@ import (
 	"github.com/dgraph-io/dgo/v230"
 	"github.com/dgraph-io/dgo/v230/protos/api"
 	"google.golang.org/grpc"
-	"next.orly.dev/pkg/encoders/filter"
 	"google.golang.org/grpc/credentials/insecure"
 	"lol.mleku.dev"
 	"lol.mleku.dev/chk"
 	"next.orly.dev/pkg/database"
+	"next.orly.dev/pkg/encoders/filter"
 	"next.orly.dev/pkg/utils/apputil"
 )

@@ -198,8 +199,11 @@ func (d *D) Mutate(ctx context.Context, mutation *api.Mutation) (*api.Response,
 		return nil, fmt.Errorf("dgraph mutation failed: %w", err)
 	}

-	if err := txn.Commit(ctx); err != nil {
-		return nil, fmt.Errorf("dgraph commit failed: %w", err)
+	// Only commit if CommitNow is false (mutation didn't auto-commit)
+	if !mutation.CommitNow {
+		if err := txn.Commit(ctx); err != nil {
+			return nil, fmt.Errorf("dgraph commit failed: %w", err)
+		}
 	}

 	return resp, nil
@@ -256,12 +260,38 @@ func (d *D) SetLogLevel(level string) {
 	// d.Logger.SetLevel(lol.GetLogLevel(level))
 }

-// EventIdsBySerial retrieves event IDs by serial range (stub)
+// EventIdsBySerial retrieves event IDs by serial range
 func (d *D) EventIdsBySerial(start uint64, count int) (
 	evs []uint64, err error,
 ) {
-	err = fmt.Errorf("not implemented")
-	return
+	// Query for events in the specified serial range
+	query := fmt.Sprintf(`{
+		events(func: ge(event.serial, %d), orderdesc: event.serial, first: %d) {
+			event.serial
+		}
+	}`, start, count)
+
+	resp, err := d.Query(context.Background(), query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query event IDs by serial: %w", err)
+	}
+
+	var result struct {
+		Events []struct {
+			Serial int64 `json:"event.serial"`
+		} `json:"events"`
+	}
+
+	if err = json.Unmarshal(resp.Json, &result); err != nil {
+		return nil, err
+	}
+
+	evs = make([]uint64, 0, len(result.Events))
+	for _, ev := range result.Events {
+		evs = append(evs, uint64(ev.Serial))
+	}
+
+	return evs, nil
 }

 // RunMigrations runs database migrations (no-op for dgraph)
--- a/pkg/dgraph/fetch-event.go
+++ b/pkg/dgraph/fetch-event.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"strings"

 	"next.orly.dev/pkg/database"
 	"next.orly.dev/pkg/database/indexes/types"
@@ -54,15 +55,16 @@ func (d *D) FetchEventsBySerials(serials []*types.Uint40) (
 		return make(map[uint64]*event.E), nil
 	}

-	// Build query for multiple serials
-	serialStrs := make([]string, len(serials))
+	// Build a filter for multiple serials using OR conditions
+	serialConditions := make([]string, len(serials))
 	for i, ser := range serials {
-		serialStrs[i] = fmt.Sprintf("%d", ser.Get())
+		serialConditions[i] = fmt.Sprintf("eq(event.serial, %d)", ser.Get())
 	}
+	serialFilter := strings.Join(serialConditions, " OR ")

-	// Use uid() function for efficient multi-get
+	// Query with proper batch filtering
 	query := fmt.Sprintf(`{
-		events(func: uid(%s)) {
+		events(func: has(event.serial)) @filter(%s) {
 			event.id
 			event.kind
 			event.created_at
@@ -72,24 +74,70 @@ func (d *D) FetchEventsBySerials(serials []*types.Uint40) (
 			event.tags
 			event.serial
 		}
-	}`, serialStrs[0]) // Simplified - in production you'd handle multiple UIDs properly
+	}`, serialFilter)

 	resp, err := d.Query(context.Background(), query)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch events by serials: %w", err)
 	}

-	evs, err := d.parseEventsFromResponse(resp.Json)
-	if err != nil {
+	// Parse the response including serial numbers
+	var result struct {
+		Events []struct {
+			ID        string `json:"event.id"`
+			Kind      int    `json:"event.kind"`
+			CreatedAt int64  `json:"event.created_at"`
+			Content   string `json:"event.content"`
+			Sig       string `json:"event.sig"`
+			Pubkey    string `json:"event.pubkey"`
+			Tags      string `json:"event.tags"`
+			Serial    int64  `json:"event.serial"`
+		} `json:"events"`
+	}
+
+	if err = json.Unmarshal(resp.Json, &result); err != nil {
 		return nil, err
 	}

-	// Map events by serial
+	// Map events by their serial numbers
 	events = make(map[uint64]*event.E)
-	for i, ser := range serials {
-		if i < len(evs) {
-			events[ser.Get()] = evs[i]
+	for _, ev := range result.Events {
+		// Decode hex strings
+		id, err := hex.Dec(ev.ID)
+		if err != nil {
+			continue
 		}
+		sig, err := hex.Dec(ev.Sig)
+		if err != nil {
+			continue
+		}
+		pubkey, err := hex.Dec(ev.Pubkey)
+		if err != nil {
+			continue
+		}
+
+		// Parse tags from JSON
+		var tags tag.S
+		if ev.Tags != "" {
+			if err := json.Unmarshal([]byte(ev.Tags), &tags); err != nil {
+				continue
+			}
+		}
+
+		// Create event
+		e := &event.E{
+			Kind:      uint16(ev.Kind),
+			CreatedAt: ev.CreatedAt,
+			Content:   []byte(ev.Content),
+			Tags:      &tags,
+		}
+
+		// Copy fixed-size arrays
+		copy(e.ID[:], id)
+		copy(e.Sig[:], sig)
+		copy(e.Pubkey[:], pubkey)
+
+		events[uint64(ev.Serial)] = e
 	}

 	return events, nil
@@ -140,17 +188,54 @@ func (d *D) GetSerialsByIds(ids *tag.T) (
 		return serials, nil
 	}

-	// Query each ID individually (simplified implementation)
-	for _, id := range ids.T {
-		if len(id) >= 2 {
-			idStr := string(id[1])
-			serial, err := d.GetSerialById([]byte(idStr))
-			if err == nil {
-				serials[idStr] = serial
-			}
+	// Build batch query for all IDs at once
+	idConditions := make([]string, 0, len(ids.T))
+	idMap := make(map[string][]byte) // Map hex ID to original bytes
+
+	for _, idBytes := range ids.T {
+		if len(idBytes) > 0 {
+			idStr := hex.Enc(idBytes)
+			idConditions = append(idConditions, fmt.Sprintf("eq(event.id, %q)", idStr))
+			idMap[idStr] = idBytes
 		}
 	}

+	if len(idConditions) == 0 {
+		return serials, nil
+	}
+
+	// Create single query with OR conditions
+	idFilter := strings.Join(idConditions, " OR ")
+	query := fmt.Sprintf(`{
+		events(func: has(event.id)) @filter(%s) {
+			event.id
+			event.serial
+		}
+	}`, idFilter)
+
+	resp, err := d.Query(context.Background(), query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to batch query serials by IDs: %w", err)
+	}
+
+	var result struct {
+		Events []struct {
+			ID     string `json:"event.id"`
+			Serial int64  `json:"event.serial"`
+		} `json:"events"`
+	}
+
+	if err = json.Unmarshal(resp.Json, &result); err != nil {
+		return nil, err
+	}
+
+	// Map results back
+	for _, ev := range result.Events {
+		serial := types.Uint40{}
+		serial.Set(uint64(ev.Serial))
+		serials[ev.ID] = &serial
+	}
+
 	return serials, nil
 }

@@ -191,10 +276,47 @@ func (d *D) GetSerialsByIdsWithFilter(
 func (d *D) GetSerialsByRange(idx database.Range) (
 	serials types.Uint40s, err error,
 ) {
-	// This would need to be implemented based on how ranges are defined
-	// For now, returning not implemented
-	err = fmt.Errorf("not implemented")
-	return
+	// Range represents a byte-prefix range for index scanning
+	// For dgraph, we need to convert this to a query on indexed fields
+	// The range is typically used for scanning event IDs or other hex-encoded keys
+
+	if len(idx.Start) == 0 && len(idx.End) == 0 {
+		return nil, fmt.Errorf("empty range provided")
+	}
+
+	startStr := hex.Enc(idx.Start)
+	endStr := hex.Enc(idx.End)
+
+	// Query for events with IDs in the specified range
+	query := fmt.Sprintf(`{
+		events(func: ge(event.id, %q)) @filter(le(event.id, %q)) {
+			event.serial
+		}
+	}`, startStr, endStr)
+
+	resp, err := d.Query(context.Background(), query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query serials by range: %w", err)
+	}
+
+	var result struct {
+		Events []struct {
+			Serial int64 `json:"event.serial"`
+		} `json:"events"`
+	}
+
+	if err = json.Unmarshal(resp.Json, &result); err != nil {
+		return nil, err
+	}
+
+	serials = make([]*types.Uint40, 0, len(result.Events))
+	for _, ev := range result.Events {
+		serial := types.Uint40{}
+		serial.Set(uint64(ev.Serial))
+		serials = append(serials, &serial)
+	}
+
+	return serials, nil
 }

 // GetFullIdPubkeyBySerial retrieves ID and pubkey for a serial number
--- a/pkg/dgraph/import-export.go
+++ b/pkg/dgraph/import-export.go
@@ -6,8 +6,10 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"strings"

 	"next.orly.dev/pkg/encoders/event"
+	"next.orly.dev/pkg/encoders/hex"
 )

 // Import imports events from a reader (JSONL format)
@@ -17,11 +19,83 @@ func (d *D) Import(rr io.Reader) {

 // Export exports events to a writer (JSONL format)
 func (d *D) Export(c context.Context, w io.Writer, pubkeys ...[]byte) {
-	// Query all events or events for specific pubkeys
-	// Write as JSONL
+	// Build query based on whether pubkeys are specified
+	var query string

-	// Stub implementation
-	fmt.Fprintf(w, "# Export not yet implemented for dgraph\n")
+	if len(pubkeys) > 0 {
+		// Build pubkey filter
+		pubkeyStrs := make([]string, len(pubkeys))
+		for i, pk := range pubkeys {
+			pubkeyStrs[i] = fmt.Sprintf("eq(event.pubkey, %q)", hex.Enc(pk))
+		}
+		pubkeyFilter := strings.Join(pubkeyStrs, " OR ")
+
+		query = fmt.Sprintf(`{
+			events(func: has(event.id)) @filter(%s) {
+				event.id
+				event.kind
+				event.created_at
+				event.content
+				event.sig
+				event.pubkey
+				event.tags
+			}
+		}`, pubkeyFilter)
+	} else {
+		// Export all events
+		query = `{
+			events(func: has(event.id)) {
+				event.id
+				event.kind
+				event.created_at
+				event.content
+				event.sig
+				event.pubkey
+				event.tags
+			}
+		}`
+	}
+
+	// Execute query
+	resp, err := d.Query(c, query)
+	if err != nil {
+		d.Logger.Errorf("failed to query events for export: %v", err)
+		fmt.Fprintf(w, "# Error: failed to query events: %v\n", err)
+		return
+	}
+
+	// Parse events
+	evs, err := d.parseEventsFromResponse(resp.Json)
+	if err != nil {
+		d.Logger.Errorf("failed to parse events for export: %v", err)
+		fmt.Fprintf(w, "# Error: failed to parse events: %v\n", err)
+		return
+	}
+
+	// Write header comment
+	fmt.Fprintf(w, "# Exported %d events from dgraph\n", len(evs))
+
+	// Write each event as JSONL
+	count := 0
+	for _, ev := range evs {
+		jsonData, err := json.Marshal(ev)
+		if err != nil {
+			d.Logger.Warningf("failed to marshal event: %v", err)
+			continue
+		}
+
+		if _, err := fmt.Fprintf(w, "%s\n", jsonData); err != nil {
+			d.Logger.Errorf("failed to write event: %v", err)
+			return
+		}
+
+		count++
+		if count%1000 == 0 {
+			d.Logger.Infof("exported %d events", count)
+		}
+	}
+
+	d.Logger.Infof("export complete: %d events written", count)
 }

 // ImportEventsFromReader imports events from a reader
--- a/pkg/dgraph/query-events.go
+++ b/pkg/dgraph/query-events.go
@@ -48,6 +48,20 @@ func (d *D) QueryEventsWithOptions(

 // buildDQLQuery constructs a DQL query from a Nostr filter
 func (d *D) buildDQLQuery(f *filter.F, includeDeleteEvents bool) string {
+	return d.buildDQLQueryWithFields(f, includeDeleteEvents, []string{
+		"uid",
+		"event.id",
+		"event.kind",
+		"event.created_at",
+		"event.content",
+		"event.sig",
+		"event.pubkey",
+		"event.tags",
+	})
+}
+
+// buildDQLQueryWithFields constructs a DQL query with custom field selection
+func (d *D) buildDQLQueryWithFields(f *filter.F, includeDeleteEvents bool, fields []string) string {
 	var conditions []string
 	var funcQuery string

@@ -139,18 +153,14 @@ func (d *D) buildDQLQuery(f *filter.F, includeDeleteEvents bool) string {
 		limitStr = fmt.Sprintf(", first: %d", f.Limit)
 	}

+	// Build field list
+	fieldStr := strings.Join(fields, "\n\t\t\t")
+
 	query := fmt.Sprintf(`{
 		events(func: %s%s%s%s) {
-			uid
-			event.id
-			event.kind
-			event.created_at
-			event.content
-			event.sig
-			event.pubkey
-			event.tags
+			%s
 		}
-	}`, funcQuery, filterStr, orderBy, limitStr)
+	}`, funcQuery, filterStr, orderBy, limitStr, fieldStr)

 	return query
 }
@@ -257,12 +267,8 @@ func (d *D) QueryDeleteEventsByTargetId(c context.Context, targetEventId []byte)
 func (d *D) QueryForSerials(c context.Context, f *filter.F) (
 	serials types.Uint40s, err error,
 ) {
-	// Build query
-	query := d.buildDQLQuery(f, false)
-
-	// Modify query to only return serial numbers
-	query = strings.Replace(query, "event.id\n\t\t\tevent.kind", "event.serial", 1)
-	query = strings.Replace(query, "\t\t\tevent.created_at\n\t\t\tevent.content\n\t\t\tevent.sig\n\t\t\tevent.pubkey\n\t\t\tevent.tags", "", 1)
+	// Build query requesting only serial numbers
+	query := d.buildDQLQueryWithFields(f, false, []string{"event.serial"})

 	resp, err := d.Query(c, query)
 	if err != nil {
@@ -293,11 +299,13 @@ func (d *D) QueryForSerials(c context.Context, f *filter.F) (
 func (d *D) QueryForIds(c context.Context, f *filter.F) (
 	idPkTs []*store.IdPkTs, err error,
 ) {
-	// Build query
-	query := d.buildDQLQuery(f, false)
-
-	// Modify query to only return ID, pubkey, created_at, serial
-	query = strings.Replace(query, "event.kind\n\t\t\tevent.created_at\n\t\t\tevent.content\n\t\t\tevent.sig\n\t\t\tevent.pubkey\n\t\t\tevent.tags", "event.id\n\t\t\tevent.pubkey\n\t\t\tevent.created_at\n\t\t\tevent.serial", 1)
+	// Build query requesting only ID, pubkey, created_at, serial
+	query := d.buildDQLQueryWithFields(f, false, []string{
+		"event.id",
+		"event.pubkey",
+		"event.created_at",
+		"event.serial",
+	})

 	resp, err := d.Query(c, query)
 	if err != nil {
@@ -342,11 +350,8 @@ func (d *D) QueryForIds(c context.Context, f *filter.F) (
 func (d *D) CountEvents(c context.Context, f *filter.F) (
 	count int, approximate bool, err error,
 ) {
-	// Build query with count
-	query := d.buildDQLQuery(f, false)
-
-	// Modify to count instead of returning full data
-	query = strings.Replace(query, "uid\n\t\t\tevent.id\n\t\t\tevent.kind\n\t\t\tevent.created_at\n\t\t\tevent.content\n\t\t\tevent.sig\n\t\t\tevent.pubkey\n\t\t\tevent.tags", "count(uid)", 1)
+	// Build query requesting only count
+	query := d.buildDQLQueryWithFields(f, false, []string{"count(uid)"})

 	resp, err := d.Query(c, query)
 	if err != nil {
--- a/pkg/dgraph/save-event.go
+++ b/pkg/dgraph/save-event.go
@@ -127,10 +127,8 @@ func (d *D) buildEventNQuads(ev *event.E, serial uint64) string {

 // GetSerialsFromFilter returns event serials matching a filter
 func (d *D) GetSerialsFromFilter(f *filter.F) (serials types.Uint40s, err error) {
-	// For dgraph, we'll use the event.serial field
-	// This is a stub implementation
-	err = fmt.Errorf("not implemented")
-	return
+	// Use QueryForSerials which already implements the proper filter logic
+	return d.QueryForSerials(context.Background(), f)
 }

 // WouldReplaceEvent checks if an event would replace existing events
--- a/pkg/neo4j/README.md
+++ b/pkg/neo4j/README.md
@@ -0,0 +1,132 @@
+# Neo4j Database Backend
+
+A graph database backend implementation for the ORLY Nostr relay using Neo4j.
+
+## Quick Start
+
+### 1. Start Neo4j
+
+```bash
+docker run -d --name neo4j \
+  -p 7474:7474 -p 7687:7687 \
+  -e NEO4J_AUTH=neo4j/password \
+  neo4j:5.15
+```
+
+### 2. Configure Environment
+
+```bash
+export ORLY_DB_TYPE=neo4j
+export ORLY_NEO4J_URI=bolt://localhost:7687
+export ORLY_NEO4J_USER=neo4j
+export ORLY_NEO4J_PASSWORD=password
+```
+
+### 3. Run ORLY
+
+```bash
+./orly
+```
+
+## Features
+
+- **Graph-Native Storage**: Events, authors, and tags stored as nodes and relationships
+- **Efficient Queries**: Leverages Neo4j's native graph traversal for tag and social graph queries
+- **Cypher Query Language**: Powerful, expressive query language for complex filters
+- **Automatic Indexing**: Unique constraints and indexes for optimal performance
+- **Relationship Queries**: Native support for event references, mentions, and tags
+
+## Architecture
+
+See [docs/NEO4J_BACKEND.md](../../docs/NEO4J_BACKEND.md) for comprehensive documentation on:
+- Graph schema design
+- How Nostr REQ messages are implemented in Cypher
+- Performance tuning
+- Development guide
+- Comparison with other backends
+
+## File Structure
+
+- `neo4j.go` - Main database implementation
+- `schema.go` - Graph schema and index definitions
+- `query-events.go` - REQ filter to Cypher translation
+- `save-event.go` - Event storage with relationship creation
+- `fetch-event.go` - Event retrieval by serial/ID
+- `serial.go` - Serial number management
+- `markers.go` - Metadata key-value storage
+- `identity.go` - Relay identity management
+- `delete.go` - Event deletion (NIP-09)
+- `subscriptions.go` - Subscription management
+- `nip43.go` - Invite-based ACL (NIP-43)
+- `import-export.go` - Event import/export
+- `logger.go` - Logging infrastructure
+
+## Testing
+
+```bash
+# Start Neo4j test instance
+docker run -d --name neo4j-test \
+  -p 7687:7687 \
+  -e NEO4J_AUTH=neo4j/test \
+  neo4j:5.15
+
+# Run tests
+ORLY_NEO4J_URI="bolt://localhost:7687" \
+ORLY_NEO4J_USER="neo4j" \
+ORLY_NEO4J_PASSWORD="test" \
+go test ./pkg/neo4j/...
+
+# Cleanup
+docker rm -f neo4j-test
+```
+
+## Example Cypher Queries
+
+### Find all events by an author
+```cypher
+MATCH (e:Event {pubkey: "abc123..."})
+RETURN e
+ORDER BY e.created_at DESC
+```
+
+### Find events with specific tags
+```cypher
+MATCH (e:Event)-[:TAGGED_WITH]->(t:Tag {type: "t", value: "bitcoin"})
+RETURN e
+```
+
+### Social graph query
+```cypher
+MATCH (author:Author {pubkey: "abc123..."})
+<-[:AUTHORED_BY]-(e:Event)
+-[:MENTIONS]->(mentioned:Author)
+RETURN author, e, mentioned
+```
+
+## Performance Tips
+
+1. **Use Limits**: Always include LIMIT in queries
+2. **Index Usage**: Ensure queries use indexed properties (id, kind, created_at)
+3. **Parameterize**: Use parameterized queries to enable query plan caching
+4. **Monitor**: Use `EXPLAIN` and `PROFILE` to analyze query performance
+
+## Limitations
+
+- Requires external Neo4j database (not embedded)
+- Higher memory usage compared to Badger
+- Metadata still uses Badger (markers, subscriptions)
+- More complex deployment than single-binary solutions
+
+## Why Neo4j for Nostr?
+
+Nostr is inherently a social graph with heavy relationship queries:
+- Event references (e-tags) → Graph edges
+- Author mentions (p-tags) → Graph edges
+- Follow relationships → Graph structure
+- Thread traversal → Path queries
+
+Neo4j excels at these patterns, making it a natural fit for relationship-heavy Nostr queries.
+
+## License
+
+Same as ORLY relay project.
--- a/pkg/neo4j/delete.go
+++ b/pkg/neo4j/delete.go
@@ -0,0 +1,173 @@
+package neo4j
+
+import (
+	"context"
+	"fmt"
+
+	"next.orly.dev/pkg/database/indexes/types"
+	"next.orly.dev/pkg/encoders/event"
+	"next.orly.dev/pkg/encoders/hex"
+)
+
+// DeleteEvent deletes an event by its ID
+func (n *N) DeleteEvent(c context.Context, eid []byte) error {
+	idStr := hex.Enc(eid)
+
+	cypher := "MATCH (e:Event {id: $id}) DETACH DELETE e"
+	params := map[string]any{"id": idStr}
+
+	_, err := n.ExecuteWrite(c, cypher, params)
+	if err != nil {
+		return fmt.Errorf("failed to delete event: %w", err)
+	}
+
+	return nil
+}
+
+// DeleteEventBySerial deletes an event by its serial number
+func (n *N) DeleteEventBySerial(c context.Context, ser *types.Uint40, ev *event.E) error {
+	serial := ser.Get()
+
+	cypher := "MATCH (e:Event {serial: $serial}) DETACH DELETE e"
+	params := map[string]any{"serial": int64(serial)}
+
+	_, err := n.ExecuteWrite(c, cypher, params)
+	if err != nil {
+		return fmt.Errorf("failed to delete event: %w", err)
+	}
+
+	return nil
+}
+
+// DeleteExpired deletes expired events (stub implementation)
+func (n *N) DeleteExpired() {
+	// This would need to implement expiration logic based on event.expiration tag (NIP-40)
+	// For now, this is a no-op
+}
+
+// ProcessDelete processes a kind 5 deletion event
+func (n *N) ProcessDelete(ev *event.E, admins [][]byte) error {
+	// Deletion events (kind 5) can delete events by the same author
+	// or by relay admins
+
+	// Check if this is a kind 5 event
+	if ev.Kind != 5 {
+		return fmt.Errorf("not a deletion event")
+	}
+
+	// Get all 'e' tags (event IDs to delete)
+	eTags := ev.Tags.GetAll([]byte{'e'})
+	if len(eTags) == 0 {
+		return nil // Nothing to delete
+	}
+
+	ctx := context.Background()
+	isAdmin := false
+
+	// Check if author is an admin
+	for _, adminPk := range admins {
+		if string(ev.Pubkey[:]) == string(adminPk) {
+			isAdmin = true
+			break
+		}
+	}
+
+	// For each event ID in e-tags, delete it if allowed
+	for _, eTag := range eTags {
+		if len(eTag.T) < 2 {
+			continue
+		}
+
+		eventIDStr := string(eTag.T[1])
+		eventID, err := hex.Dec(eventIDStr)
+		if err != nil {
+			continue
+		}
+
+		// Fetch the event to check authorship
+		cypher := "MATCH (e:Event {id: $id}) RETURN e.pubkey AS pubkey"
+		params := map[string]any{"id": eventIDStr}
+
+		result, err := n.ExecuteRead(ctx, cypher, params)
+		if err != nil {
+			continue
+		}
+
+		neo4jResult, ok := result.(interface {
+			Next(context.Context) bool
+			Record() *interface{}
+			Err() error
+		})
+		if !ok {
+			continue
+		}
+
+		if neo4jResult.Next(ctx) {
+			record := neo4jResult.Record()
+			if record != nil {
+				recordMap, ok := (*record).(map[string]any)
+				if ok {
+					if pubkeyStr, ok := recordMap["pubkey"].(string); ok {
+						pubkey, err := hex.Dec(pubkeyStr)
+						if err != nil {
+							continue
+						}
+
+						// Check if deletion is allowed (same author or admin)
+						canDelete := isAdmin || string(ev.Pubkey[:]) == string(pubkey)
+						if canDelete {
+							// Delete the event
+							if err := n.DeleteEvent(ctx, eventID); err != nil {
+								n.Logger.Warningf("failed to delete event %s: %v", eventIDStr, err)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+// CheckForDeleted checks if an event has been deleted
+func (n *N) CheckForDeleted(ev *event.E, admins [][]byte) error {
+	// Query for kind 5 events that reference this event
+	ctx := context.Background()
+	idStr := hex.Enc(ev.ID[:])
+
+	// Build cypher query to find deletion events
+	cypher := `
+MATCH (target:Event {id: $targetId})
+MATCH (delete:Event {kind: 5})-[:REFERENCES]->(target)
+WHERE delete.pubkey = $pubkey OR delete.pubkey IN $admins
+RETURN delete.id AS id
+LIMIT 1`
+
+	adminPubkeys := make([]string, len(admins))
+	for i, admin := range admins {
+		adminPubkeys[i] = hex.Enc(admin)
+	}
+
+	params := map[string]any{
+		"targetId": idStr,
+		"pubkey":   hex.Enc(ev.Pubkey[:]),
+		"admins":   adminPubkeys,
+	}
+
+	result, err := n.ExecuteRead(ctx, cypher, params)
+	if err != nil {
+		return nil // Not deleted
+	}
+
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if ok && neo4jResult.Next(ctx) {
+		return fmt.Errorf("event has been deleted")
+	}
+
+	return nil
+}
--- a/pkg/neo4j/fetch-event.go
+++ b/pkg/neo4j/fetch-event.go
@@ -0,0 +1,444 @@
+package neo4j
+
+import (
+	"context"
+	"fmt"
+
+	"next.orly.dev/pkg/database"
+	"next.orly.dev/pkg/database/indexes/types"
+	"next.orly.dev/pkg/encoders/event"
+	"next.orly.dev/pkg/encoders/hex"
+	"next.orly.dev/pkg/encoders/tag"
+	"next.orly.dev/pkg/interfaces/store"
+)
+
+// FetchEventBySerial retrieves an event by its serial number
+func (n *N) FetchEventBySerial(ser *types.Uint40) (ev *event.E, err error) {
+	serial := ser.Get()
+
+	cypher := `
+MATCH (e:Event {serial: $serial})
+RETURN e.id AS id,
+       e.kind AS kind,
+       e.created_at AS created_at,
+       e.content AS content,
+       e.sig AS sig,
+       e.pubkey AS pubkey,
+       e.tags AS tags`
+
+	params := map[string]any{"serial": int64(serial)}
+
+	result, err := n.ExecuteRead(context.Background(), cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch event by serial: %w", err)
+	}
+
+	evs, err := n.parseEventsFromResult(result)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(evs) == 0 {
+		return nil, fmt.Errorf("event not found")
+	}
+
+	return evs[0], nil
+}
+
+// FetchEventsBySerials retrieves multiple events by their serial numbers
+func (n *N) FetchEventsBySerials(serials []*types.Uint40) (
+	events map[uint64]*event.E, err error,
+) {
+	if len(serials) == 0 {
+		return make(map[uint64]*event.E), nil
+	}
+
+	// Build list of serial numbers
+	serialNums := make([]int64, len(serials))
+	for i, ser := range serials {
+		serialNums[i] = int64(ser.Get())
+	}
+
+	cypher := `
+MATCH (e:Event)
+WHERE e.serial IN $serials
+RETURN e.id AS id,
+       e.kind AS kind,
+       e.created_at AS created_at,
+       e.content AS content,
+       e.sig AS sig,
+       e.pubkey AS pubkey,
+       e.tags AS tags,
+       e.serial AS serial`
+
+	params := map[string]any{"serials": serialNums}
+
+	result, err := n.ExecuteRead(context.Background(), cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch events by serials: %w", err)
+	}
+
+	// Parse events and map by serial
+	events = make(map[uint64]*event.E)
+	ctx := context.Background()
+
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return events, nil
+	}
+
+	for neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record == nil {
+			continue
+		}
+
+		recordMap, ok := (*record).(map[string]any)
+		if !ok {
+			continue
+		}
+
+		// Parse event
+		idStr, _ := recordMap["id"].(string)
+		kind, _ := recordMap["kind"].(int64)
+		createdAt, _ := recordMap["created_at"].(int64)
+		content, _ := recordMap["content"].(string)
+		sigStr, _ := recordMap["sig"].(string)
+		pubkeyStr, _ := recordMap["pubkey"].(string)
+		tagsStr, _ := recordMap["tags"].(string)
+		serialVal, _ := recordMap["serial"].(int64)
+
+		id, err := hex.Dec(idStr)
+		if err != nil {
+			continue
+		}
+		sig, err := hex.Dec(sigStr)
+		if err != nil {
+			continue
+		}
+		pubkey, err := hex.Dec(pubkeyStr)
+		if err != nil {
+			continue
+		}
+
+		tags := tag.NewS()
+		if tagsStr != "" {
+			_ = tags.UnmarshalJSON([]byte(tagsStr))
+		}
+
+		e := &event.E{
+			Kind:      uint16(kind),
+			CreatedAt: createdAt,
+			Content:   []byte(content),
+			Tags:      tags,
+		}
+
+		copy(e.ID[:], id)
+		copy(e.Sig[:], sig)
+		copy(e.Pubkey[:], pubkey)
+
+		events[uint64(serialVal)] = e
+	}
+
+	return events, nil
+}
+
+// GetSerialById retrieves the serial number for an event ID
+func (n *N) GetSerialById(id []byte) (ser *types.Uint40, err error) {
+	idStr := hex.Enc(id)
+
+	cypher := "MATCH (e:Event {id: $id}) RETURN e.serial AS serial"
+	params := map[string]any{"id": idStr}
+
+	result, err := n.ExecuteRead(context.Background(), cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get serial by ID: %w", err)
+	}
+
+	ctx := context.Background()
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return nil, fmt.Errorf("invalid result type")
+	}
+
+	if neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record != nil {
+			recordMap, ok := (*record).(map[string]any)
+			if ok {
+				if serialVal, ok := recordMap["serial"].(int64); ok {
+					ser = &types.Uint40{}
+					ser.Set(uint64(serialVal))
+					return ser, nil
+				}
+			}
+		}
+	}
+
+	return nil, fmt.Errorf("event not found")
+}
+
+// GetSerialsByIds retrieves serial numbers for multiple event IDs
+func (n *N) GetSerialsByIds(ids *tag.T) (
+	serials map[string]*types.Uint40, err error,
+) {
+	serials = make(map[string]*types.Uint40)
+
+	if len(ids.T) == 0 {
+		return serials, nil
+	}
+
+	// Extract ID strings
+	idStrs := make([]string, 0, len(ids.T))
+	for _, idTag := range ids.T {
+		if len(idTag) >= 2 {
+			idStrs = append(idStrs, string(idTag[1]))
+		}
+	}
+
+	if len(idStrs) == 0 {
+		return serials, nil
+	}
+
+	cypher := `
+MATCH (e:Event)
+WHERE e.id IN $ids
+RETURN e.id AS id, e.serial AS serial`
+
+	params := map[string]any{"ids": idStrs}
+
+	result, err := n.ExecuteRead(context.Background(), cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get serials by IDs: %w", err)
+	}
+
+	ctx := context.Background()
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return serials, nil
+	}
+
+	for neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record == nil {
+			continue
+		}
+
+		recordMap, ok := (*record).(map[string]any)
+		if !ok {
+			continue
+		}
+
+		idStr, _ := recordMap["id"].(string)
+		serialVal, _ := recordMap["serial"].(int64)
+
+		serial := &types.Uint40{}
+		serial.Set(uint64(serialVal))
+		serials[idStr] = serial
+	}
+
+	return serials, nil
+}
+
+// GetSerialsByIdsWithFilter retrieves serials with a filter function
+func (n *N) GetSerialsByIdsWithFilter(
+	ids *tag.T, fn func(ev *event.E, ser *types.Uint40) bool,
+) (serials map[string]*types.Uint40, err error) {
+	serials = make(map[string]*types.Uint40)
+
+	if fn == nil {
+		// No filter, just return all
+		return n.GetSerialsByIds(ids)
+	}
+
+	// With filter, need to fetch events
+	for _, idTag := range ids.T {
+		if len(idTag) < 2 {
+			continue
+		}
+
+		idBytes, err := hex.Dec(string(idTag[1]))
+		if err != nil {
+			continue
+		}
+
+		serial, err := n.GetSerialById(idBytes)
+		if err != nil {
+			continue
+		}
+
+		ev, err := n.FetchEventBySerial(serial)
+		if err != nil {
+			continue
+		}
+
+		if fn(ev, serial) {
+			serials[string(idTag[1])] = serial
+		}
+	}
+
+	return serials, nil
+}
+
+// GetSerialsByRange retrieves serials within a range
+func (n *N) GetSerialsByRange(idx database.Range) (
+	serials types.Uint40s, err error,
+) {
+	// This would need to be implemented based on how ranges are defined
+	// For now, returning not implemented
+	err = fmt.Errorf("not implemented")
+	return
+}
+
+// GetFullIdPubkeyBySerial retrieves ID and pubkey for a serial number
+func (n *N) GetFullIdPubkeyBySerial(ser *types.Uint40) (
+	fidpk *store.IdPkTs, err error,
+) {
+	serial := ser.Get()
+
+	cypher := `
+MATCH (e:Event {serial: $serial})
+RETURN e.id AS id,
+       e.pubkey AS pubkey,
+       e.created_at AS created_at`
+
+	params := map[string]any{"serial": int64(serial)}
+
+	result, err := n.ExecuteRead(context.Background(), cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get ID and pubkey by serial: %w", err)
+	}
+
+	ctx := context.Background()
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return nil, fmt.Errorf("invalid result type")
+	}
+
+	if neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record != nil {
+			recordMap, ok := (*record).(map[string]any)
+			if ok {
+				idStr, _ := recordMap["id"].(string)
+				pubkeyStr, _ := recordMap["pubkey"].(string)
+				createdAt, _ := recordMap["created_at"].(int64)
+
+				id, err := hex.Dec(idStr)
+				if err != nil {
+					return nil, err
+				}
+
+				pubkey, err := hex.Dec(pubkeyStr)
+				if err != nil {
+					return nil, err
+				}
+
+				fidpk = &store.IdPkTs{
+					Id:  id,
+					Pub: pubkey,
+					Ts:  createdAt,
+					Ser: serial,
+				}
+
+				return fidpk, nil
+			}
+		}
+	}
+
+	return nil, fmt.Errorf("event not found")
+}
+
+// GetFullIdPubkeyBySerials retrieves IDs and pubkeys for multiple serials
+func (n *N) GetFullIdPubkeyBySerials(sers []*types.Uint40) (
+	fidpks []*store.IdPkTs, err error,
+) {
+	fidpks = make([]*store.IdPkTs, 0, len(sers))
+
+	if len(sers) == 0 {
+		return fidpks, nil
+	}
+
+	// Build list of serial numbers
+	serialNums := make([]int64, len(sers))
+	for i, ser := range sers {
+		serialNums[i] = int64(ser.Get())
+	}
+
+	cypher := `
+MATCH (e:Event)
+WHERE e.serial IN $serials
+RETURN e.id AS id,
+       e.pubkey AS pubkey,
+       e.created_at AS created_at,
+       e.serial AS serial`
+
+	params := map[string]any{"serials": serialNums}
+
+	result, err := n.ExecuteRead(context.Background(), cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get IDs and pubkeys by serials: %w", err)
+	}
+
+	ctx := context.Background()
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return fidpks, nil
+	}
+
+	for neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record == nil {
+			continue
+		}
+
+		recordMap, ok := (*record).(map[string]any)
+		if !ok {
+			continue
+		}
+
+		idStr, _ := recordMap["id"].(string)
+		pubkeyStr, _ := recordMap["pubkey"].(string)
+		createdAt, _ := recordMap["created_at"].(int64)
+		serialVal, _ := recordMap["serial"].(int64)
+
+		id, err := hex.Dec(idStr)
+		if err != nil {
+			continue
+		}
+
+		pubkey, err := hex.Dec(pubkeyStr)
+		if err != nil {
+			continue
+		}
+
+		fidpks = append(fidpks, &store.IdPkTs{
+			Id:  id,
+			Pub:  pubkey,
+			Ts:  createdAt,
+			Ser: uint64(serialVal),
+		})
+	}
+
+	return fidpks, nil
+}
--- a/pkg/neo4j/identity.go
+++ b/pkg/neo4j/identity.go
@@ -0,0 +1,44 @@
+package neo4j
+
+import (
+	"fmt"
+
+	"next.orly.dev/pkg/crypto/keys"
+)
+
+// Relay identity methods
+// We use the marker system to store the relay's private key
+
+const relayIdentityMarkerKey = "relay_identity_secret"
+
+// GetRelayIdentitySecret retrieves the relay's identity secret key
+func (n *N) GetRelayIdentitySecret() (skb []byte, err error) {
+	return n.GetMarker(relayIdentityMarkerKey)
+}
+
+// SetRelayIdentitySecret sets the relay's identity secret key
+func (n *N) SetRelayIdentitySecret(skb []byte) error {
+	return n.SetMarker(relayIdentityMarkerKey, skb)
+}
+
+// GetOrCreateRelayIdentitySecret retrieves or creates the relay identity
+func (n *N) GetOrCreateRelayIdentitySecret() (skb []byte, err error) {
+	skb, err = n.GetRelayIdentitySecret()
+	if err == nil {
+		return skb, nil
+	}
+
+	// Generate new identity
+	skb, err = keys.GenerateSecretKey()
+	if err != nil {
+		return nil, fmt.Errorf("failed to generate identity: %w", err)
+	}
+
+	// Store it
+	if err = n.SetRelayIdentitySecret(skb); err != nil {
+		return nil, fmt.Errorf("failed to store identity: %w", err)
+	}
+
+	n.Logger.Infof("generated new relay identity")
+	return skb, nil
+}
--- a/pkg/neo4j/import-export.go
+++ b/pkg/neo4j/import-export.go
@@ -0,0 +1,97 @@
+package neo4j
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"next.orly.dev/pkg/encoders/event"
+)
+
+// Import imports events from a reader (JSONL format)
+func (n *N) Import(rr io.Reader) {
+	n.ImportEventsFromReader(context.Background(), rr)
+}
+
+// Export exports events to a writer (JSONL format)
+func (n *N) Export(c context.Context, w io.Writer, pubkeys ...[]byte) {
+	// Query all events or events for specific pubkeys
+	// Write as JSONL
+
+	// Stub implementation
+	fmt.Fprintf(w, "# Export not yet implemented for neo4j\n")
+}
+
+// ImportEventsFromReader imports events from a reader
+func (n *N) ImportEventsFromReader(ctx context.Context, rr io.Reader) error {
+	scanner := bufio.NewScanner(rr)
+	scanner.Buffer(make([]byte, 1024*1024), 10*1024*1024) // 10MB max line size
+
+	count := 0
+	for scanner.Scan() {
+		line := scanner.Bytes()
+		if len(line) == 0 {
+			continue
+		}
+
+		// Skip comments
+		if line[0] == '#' {
+			continue
+		}
+
+		// Parse event
+		ev := &event.E{}
+		if err := json.Unmarshal(line, ev); err != nil {
+			n.Logger.Warningf("failed to parse event: %v", err)
+			continue
+		}
+
+		// Save event
+		if _, err := n.SaveEvent(ctx, ev); err != nil {
+			n.Logger.Warningf("failed to import event: %v", err)
+			continue
+		}
+
+		count++
+		if count%1000 == 0 {
+			n.Logger.Infof("imported %d events", count)
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return fmt.Errorf("scanner error: %w", err)
+	}
+
+	n.Logger.Infof("import complete: %d events", count)
+	return nil
+}
+
+// ImportEventsFromStrings imports events from JSON strings
+func (n *N) ImportEventsFromStrings(
+	ctx context.Context,
+	eventJSONs []string,
+	policyManager interface{ CheckPolicy(action string, ev *event.E, pubkey []byte, remote string) (bool, error) },
+) error {
+	for _, eventJSON := range eventJSONs {
+		ev := &event.E{}
+		if err := json.Unmarshal([]byte(eventJSON), ev); err != nil {
+			continue
+		}
+
+		// Check policy if manager is provided
+		if policyManager != nil {
+			if allowed, err := policyManager.CheckPolicy("write", ev, ev.Pubkey[:], "import"); err != nil || !allowed {
+				continue
+			}
+		}
+
+		// Save event
+		if _, err := n.SaveEvent(ctx, ev); err != nil {
+			n.Logger.Warningf("failed to import event: %v", err)
+		}
+	}
+
+	return nil
+}
--- a/pkg/neo4j/logger.go
+++ b/pkg/neo4j/logger.go
@@ -0,0 +1,68 @@
+package neo4j
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+
+	"go.uber.org/atomic"
+	"lol.mleku.dev"
+	"lol.mleku.dev/log"
+)
+
+// NewLogger creates a new dgraph logger.
+func NewLogger(logLevel int, label string) (l *logger) {
+	l = &logger{Label: label}
+	l.Level.Store(int32(logLevel))
+	return
+}
+
+type logger struct {
+	Level atomic.Int32
+	Label string
+}
+
+// SetLogLevel atomically adjusts the log level to the given log level code.
+func (l *logger) SetLogLevel(level int) {
+	l.Level.Store(int32(level))
+}
+
+// Errorf is a log printer for this level of message.
+func (l *logger) Errorf(s string, i ...interface{}) {
+	if l.Level.Load() >= lol.Error {
+		s = l.Label + ": " + s
+		txt := fmt.Sprintf(s, i...)
+		_, file, line, _ := runtime.Caller(2)
+		log.E.F("%s\n%s:%d", strings.TrimSpace(txt), file, line)
+	}
+}
+
+// Warningf is a log printer for this level of message.
+func (l *logger) Warningf(s string, i ...interface{}) {
+	if l.Level.Load() >= lol.Warn {
+		s = l.Label + ": " + s
+		txt := fmt.Sprintf(s, i...)
+		_, file, line, _ := runtime.Caller(2)
+		log.W.F("%s\n%s:%d", strings.TrimSpace(txt), file, line)
+	}
+}
+
+// Infof is a log printer for this level of message.
+func (l *logger) Infof(s string, i ...interface{}) {
+	if l.Level.Load() >= lol.Info {
+		s = l.Label + ": " + s
+		txt := fmt.Sprintf(s, i...)
+		_, file, line, _ := runtime.Caller(2)
+		log.I.F("%s\n%s:%d", strings.TrimSpace(txt), file, line)
+	}
+}
+
+// Debugf is a log printer for this level of message.
+func (l *logger) Debugf(s string, i ...interface{}) {
+	if l.Level.Load() >= lol.Debug {
+		s = l.Label + ": " + s
+		txt := fmt.Sprintf(s, i...)
+		_, file, line, _ := runtime.Caller(2)
+		log.D.F("%s\n%s:%d", strings.TrimSpace(txt), file, line)
+	}
+}
--- a/pkg/neo4j/markers.go
+++ b/pkg/neo4j/markers.go
@@ -0,0 +1,91 @@
+package neo4j
+
+import (
+	"context"
+	"fmt"
+
+	"next.orly.dev/pkg/encoders/hex"
+)
+
+// Markers provide metadata key-value storage using Neo4j Marker nodes
+// We store markers as special nodes with label "Marker"
+
+// SetMarker sets a metadata marker
+func (n *N) SetMarker(key string, value []byte) error {
+	valueHex := hex.Enc(value)
+
+	cypher := `
+MERGE (m:Marker {key: $key})
+SET m.value = $value`
+
+	params := map[string]any{
+		"key":   key,
+		"value": valueHex,
+	}
+
+	_, err := n.ExecuteWrite(context.Background(), cypher, params)
+	if err != nil {
+		return fmt.Errorf("failed to set marker: %w", err)
+	}
+
+	return nil
+}
+
+// GetMarker retrieves a metadata marker
+func (n *N) GetMarker(key string) (value []byte, err error) {
+	cypher := "MATCH (m:Marker {key: $key}) RETURN m.value AS value"
+	params := map[string]any{"key": key}
+
+	result, err := n.ExecuteRead(context.Background(), cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get marker: %w", err)
+	}
+
+	ctx := context.Background()
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return nil, fmt.Errorf("invalid result type")
+	}
+
+	if neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record != nil {
+			recordMap, ok := (*record).(map[string]any)
+			if ok {
+				if valueStr, ok := recordMap["value"].(string); ok {
+					// Decode hex value
+					value, err = hex.Dec(valueStr)
+					if err != nil {
+						return nil, fmt.Errorf("failed to decode marker value: %w", err)
+					}
+					return value, nil
+				}
+			}
+		}
+	}
+
+	return nil, fmt.Errorf("marker not found: %s", key)
+}
+
+// HasMarker checks if a marker exists
+func (n *N) HasMarker(key string) bool {
+	_, err := n.GetMarker(key)
+	return err == nil
+}
+
+// DeleteMarker removes a metadata marker
+func (n *N) DeleteMarker(key string) error {
+	cypher := "MATCH (m:Marker {key: $key}) DELETE m"
+	params := map[string]any{"key": key}
+
+	_, err := n.ExecuteWrite(context.Background(), cypher, params)
+	if err != nil {
+		return fmt.Errorf("failed to delete marker: %w", err)
+	}
+
+	return nil
+}
--- a/pkg/neo4j/neo4j.go
+++ b/pkg/neo4j/neo4j.go
@@ -0,0 +1,321 @@
+// Package neo4j provides a Neo4j-based implementation of the database interface.
+// Neo4j is a native graph database optimized for relationship-heavy queries,
+// making it ideal for Nostr's social graph and event reference patterns.
+package neo4j
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/dgraph-io/badger/v4"
+	"github.com/neo4j/neo4j-go-driver/v5/neo4j"
+	"lol.mleku.dev"
+	"lol.mleku.dev/chk"
+	"next.orly.dev/pkg/database"
+	"next.orly.dev/pkg/encoders/filter"
+	"next.orly.dev/pkg/utils/apputil"
+)
+
+// N implements the database.Database interface using Neo4j as the storage backend
+type N struct {
+	ctx     context.Context
+	cancel  context.CancelFunc
+	dataDir string
+	Logger  *logger
+
+	// Neo4j client connection
+	driver neo4j.DriverWithContext
+
+	// Fallback badger storage for metadata (markers, identity, etc.)
+	pstore *badger.DB
+
+	// Configuration
+	neo4jURI      string
+	neo4jUser     string
+	neo4jPassword string
+
+	ready chan struct{} // Closed when database is ready to serve requests
+}
+
+// Ensure N implements database.Database interface at compile time
+var _ database.Database = (*N)(nil)
+
+// init registers the neo4j database factory
+func init() {
+	database.RegisterNeo4jFactory(func(
+		ctx context.Context,
+		cancel context.CancelFunc,
+		dataDir string,
+		logLevel string,
+	) (database.Database, error) {
+		return New(ctx, cancel, dataDir, logLevel)
+	})
+}
+
+// Config holds configuration options for the Neo4j database
+type Config struct {
+	DataDir       string
+	LogLevel      string
+	Neo4jURI      string // Neo4j bolt URI (e.g., "bolt://localhost:7687")
+	Neo4jUser     string // Authentication username
+	Neo4jPassword string // Authentication password
+}
+
+// New creates a new Neo4j-based database instance
+func New(
+	ctx context.Context, cancel context.CancelFunc, dataDir, logLevel string,
+) (
+	n *N, err error,
+) {
+	// Get Neo4j connection details from environment
+	neo4jURI := os.Getenv("ORLY_NEO4J_URI")
+	if neo4jURI == "" {
+		neo4jURI = "bolt://localhost:7687"
+	}
+	neo4jUser := os.Getenv("ORLY_NEO4J_USER")
+	if neo4jUser == "" {
+		neo4jUser = "neo4j"
+	}
+	neo4jPassword := os.Getenv("ORLY_NEO4J_PASSWORD")
+	if neo4jPassword == "" {
+		neo4jPassword = "password"
+	}
+
+	n = &N{
+		ctx:           ctx,
+		cancel:        cancel,
+		dataDir:       dataDir,
+		Logger:        NewLogger(lol.GetLogLevel(logLevel), dataDir),
+		neo4jURI:      neo4jURI,
+		neo4jUser:     neo4jUser,
+		neo4jPassword: neo4jPassword,
+		ready:         make(chan struct{}),
+	}
+
+	// Ensure the data directory exists
+	if err = os.MkdirAll(dataDir, 0755); chk.E(err) {
+		return
+	}
+
+	// Ensure directory structure
+	dummyFile := filepath.Join(dataDir, "dummy.sst")
+	if err = apputil.EnsureDir(dummyFile); chk.E(err) {
+		return
+	}
+
+	// Initialize neo4j client connection
+	if err = n.initNeo4jClient(); chk.E(err) {
+		return
+	}
+
+	// Initialize badger for metadata storage
+	if err = n.initStorage(); chk.E(err) {
+		return
+	}
+
+	// Apply Nostr schema to neo4j (create constraints and indexes)
+	if err = n.applySchema(ctx); chk.E(err) {
+		return
+	}
+
+	// Initialize serial counter
+	if err = n.initSerialCounter(); chk.E(err) {
+		return
+	}
+
+	// Start warmup goroutine to signal when database is ready
+	go n.warmup()
+
+	// Setup shutdown handler
+	go func() {
+		<-n.ctx.Done()
+		n.cancel()
+		if n.driver != nil {
+			n.driver.Close(context.Background())
+		}
+		if n.pstore != nil {
+			n.pstore.Close()
+		}
+	}()
+
+	return
+}
+
+// initNeo4jClient establishes connection to Neo4j server
+func (n *N) initNeo4jClient() error {
+	n.Logger.Infof("connecting to neo4j at %s", n.neo4jURI)
+
+	// Create Neo4j driver
+	driver, err := neo4j.NewDriverWithContext(
+		n.neo4jURI,
+		neo4j.BasicAuth(n.neo4jUser, n.neo4jPassword, ""),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to create neo4j driver: %w", err)
+	}
+
+	n.driver = driver
+
+	// Verify connectivity
+	ctx := context.Background()
+	if err := driver.VerifyConnectivity(ctx); err != nil {
+		return fmt.Errorf("failed to verify neo4j connectivity: %w", err)
+	}
+
+	n.Logger.Infof("successfully connected to neo4j")
+	return nil
+}
+
+// initStorage opens Badger database for metadata storage
+func (n *N) initStorage() error {
+	metadataDir := filepath.Join(n.dataDir, "metadata")
+
+	if err := os.MkdirAll(metadataDir, 0755); err != nil {
+		return fmt.Errorf("failed to create metadata directory: %w", err)
+	}
+
+	opts := badger.DefaultOptions(metadataDir)
+
+	var err error
+	n.pstore, err = badger.Open(opts)
+	if err != nil {
+		return fmt.Errorf("failed to open badger metadata store: %w", err)
+	}
+
+	n.Logger.Infof("metadata storage initialized")
+	return nil
+}
+
+// ExecuteRead executes a read query against Neo4j
+func (n *N) ExecuteRead(ctx context.Context, cypher string, params map[string]any) (neo4j.ResultWithContext, error) {
+	session := n.driver.NewSession(ctx, neo4j.SessionConfig{AccessMode: neo4j.AccessModeRead})
+	defer session.Close(ctx)
+
+	result, err := session.Run(ctx, cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("neo4j read query failed: %w", err)
+	}
+
+	return result, nil
+}
+
+// ExecuteWrite executes a write query against Neo4j
+func (n *N) ExecuteWrite(ctx context.Context, cypher string, params map[string]any) (neo4j.ResultWithContext, error) {
+	session := n.driver.NewSession(ctx, neo4j.SessionConfig{AccessMode: neo4j.AccessModeWrite})
+	defer session.Close(ctx)
+
+	result, err := session.Run(ctx, cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("neo4j write query failed: %w", err)
+	}
+
+	return result, nil
+}
+
+// ExecuteWriteTransaction executes a transactional write operation
+func (n *N) ExecuteWriteTransaction(ctx context.Context, work func(tx neo4j.ManagedTransaction) (any, error)) (any, error) {
+	session := n.driver.NewSession(ctx, neo4j.SessionConfig{AccessMode: neo4j.AccessModeWrite})
+	defer session.Close(ctx)
+
+	return session.ExecuteWrite(ctx, work)
+}
+
+// Path returns the data directory path
+func (n *N) Path() string { return n.dataDir }
+
+// Init initializes the database with a given path (no-op, path set in New)
+func (n *N) Init(path string) (err error) {
+	// Path already set in New()
+	return nil
+}
+
+// Sync flushes pending writes
+func (n *N) Sync() (err error) {
+	if n.pstore != nil {
+		return n.pstore.Sync()
+	}
+	return nil
+}
+
+// Close closes the database
+func (n *N) Close() (err error) {
+	n.cancel()
+	if n.driver != nil {
+		if e := n.driver.Close(context.Background()); e != nil {
+			err = e
+		}
+	}
+	if n.pstore != nil {
+		if e := n.pstore.Close(); e != nil && err == nil {
+			err = e
+		}
+	}
+	return
+}
+
+// Wipe removes all data
+func (n *N) Wipe() (err error) {
+	// Close and remove badger metadata
+	if n.pstore != nil {
+		if err = n.pstore.Close(); chk.E(err) {
+			return
+		}
+	}
+	if err = os.RemoveAll(n.dataDir); chk.E(err) {
+		return
+	}
+
+	// Delete all nodes and relationships in Neo4j
+	ctx := context.Background()
+	_, err = n.ExecuteWrite(ctx, "MATCH (n) DETACH DELETE n", nil)
+	if err != nil {
+		return fmt.Errorf("failed to wipe neo4j database: %w", err)
+	}
+
+	return n.initStorage()
+}
+
+// SetLogLevel sets the logging level
+func (n *N) SetLogLevel(level string) {
+	// n.Logger.SetLevel(lol.GetLogLevel(level))
+}
+
+// EventIdsBySerial retrieves event IDs by serial range (stub)
+func (n *N) EventIdsBySerial(start uint64, count int) (
+	evs []uint64, err error,
+) {
+	err = fmt.Errorf("not implemented")
+	return
+}
+
+// RunMigrations runs database migrations (no-op for neo4j)
+func (n *N) RunMigrations() {
+	// No-op for neo4j
+}
+
+// Ready returns a channel that closes when the database is ready to serve requests.
+// This allows callers to wait for database warmup to complete.
+func (n *N) Ready() <-chan struct{} {
+	return n.ready
+}
+
+// warmup performs database warmup operations and closes the ready channel when complete.
+// For Neo4j, warmup ensures the connection is healthy and constraints are applied.
+func (n *N) warmup() {
+	defer close(n.ready)
+
+	// Neo4j connection and schema are already verified during initialization
+	// Just give a brief moment for any background processes to settle
+	n.Logger.Infof("neo4j database warmup complete, ready to serve requests")
+}
+
+// GetCachedJSON returns cached query results (not implemented for Neo4j)
+func (n *N) GetCachedJSON(f *filter.F) ([][]byte, bool) { return nil, false }
+
+// CacheMarshaledJSON caches marshaled JSON results (not implemented for Neo4j)
+func (n *N) CacheMarshaledJSON(f *filter.F, marshaledJSON [][]byte) {}
+
+// InvalidateQueryCache invalidates the query cache (not implemented for Neo4j)
+func (n *N) InvalidateQueryCache() {}
--- a/pkg/neo4j/nip43.go
+++ b/pkg/neo4j/nip43.go
@@ -0,0 +1,212 @@
+package neo4j
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"next.orly.dev/pkg/database"
+	"next.orly.dev/pkg/encoders/hex"
+)
+
+// NIP-43 Invite-based ACL methods
+// Simplified implementation using marker-based storage via Badger
+// For production, these could use Neo4j nodes with relationships
+
+// AddNIP43Member adds a member using an invite code
+func (n *N) AddNIP43Member(pubkey []byte, inviteCode string) error {
+	key := "nip43_" + hex.Enc(pubkey)
+
+	member := database.NIP43Membership{
+		InviteCode: inviteCode,
+		AddedAt:    time.Now(),
+	}
+	copy(member.Pubkey[:], pubkey)
+
+	data, err := json.Marshal(member)
+	if err != nil {
+		return fmt.Errorf("failed to marshal membership: %w", err)
+	}
+
+	// Also add to members list
+	if err := n.addToMembersList(pubkey); err != nil {
+		return err
+	}
+
+	return n.SetMarker(key, data)
+}
+
+// RemoveNIP43Member removes a member
+func (n *N) RemoveNIP43Member(pubkey []byte) error {
+	key := "nip43_" + hex.Enc(pubkey)
+
+	// Remove from members list
+	if err := n.removeFromMembersList(pubkey); err != nil {
+		return err
+	}
+
+	return n.DeleteMarker(key)
+}
+
+// IsNIP43Member checks if a pubkey is a member
+func (n *N) IsNIP43Member(pubkey []byte) (isMember bool, err error) {
+	_, err = n.GetNIP43Membership(pubkey)
+	return err == nil, nil
+}
+
+// GetNIP43Membership retrieves membership information
+func (n *N) GetNIP43Membership(pubkey []byte) (*database.NIP43Membership, error) {
+	key := "nip43_" + hex.Enc(pubkey)
+
+	data, err := n.GetMarker(key)
+	if err != nil {
+		return nil, err
+	}
+
+	var member database.NIP43Membership
+	if err := json.Unmarshal(data, &member); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal membership: %w", err)
+	}
+
+	return &member, nil
+}
+
+// GetAllNIP43Members retrieves all member pubkeys
+func (n *N) GetAllNIP43Members() ([][]byte, error) {
+	data, err := n.GetMarker("nip43_members_list")
+	if err != nil {
+		return nil, nil // No members = empty list
+	}
+
+	var members []string
+	if err := json.Unmarshal(data, &members); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal members list: %w", err)
+	}
+
+	result := make([][]byte, 0, len(members))
+	for _, hexPubkey := range members {
+		pubkey, err := hex.Dec(hexPubkey)
+		if err != nil {
+			continue
+		}
+		result = append(result, pubkey)
+	}
+
+	return result, nil
+}
+
+// StoreInviteCode stores an invite code with expiration
+func (n *N) StoreInviteCode(code string, expiresAt time.Time) error {
+	key := "invite_" + code
+
+	inviteData := map[string]interface{}{
+		"code":      code,
+		"expiresAt": expiresAt,
+	}
+
+	data, err := json.Marshal(inviteData)
+	if err != nil {
+		return fmt.Errorf("failed to marshal invite: %w", err)
+	}
+
+	return n.SetMarker(key, data)
+}
+
+// ValidateInviteCode checks if an invite code is valid
+func (n *N) ValidateInviteCode(code string) (valid bool, err error) {
+	key := "invite_" + code
+
+	data, err := n.GetMarker(key)
+	if err != nil {
+		return false, nil // Code doesn't exist
+	}
+
+	var inviteData map[string]interface{}
+	if err := json.Unmarshal(data, &inviteData); err != nil {
+		return false, fmt.Errorf("failed to unmarshal invite: %w", err)
+	}
+
+	// Check expiration
+	if expiresStr, ok := inviteData["expiresAt"].(string); ok {
+		expiresAt, err := time.Parse(time.RFC3339, expiresStr)
+		if err == nil && time.Now().After(expiresAt) {
+			return false, nil // Expired
+		}
+	}
+
+	return true, nil
+}
+
+// DeleteInviteCode removes an invite code
+func (n *N) DeleteInviteCode(code string) error {
+	key := "invite_" + code
+	return n.DeleteMarker(key)
+}
+
+// PublishNIP43MembershipEvent publishes a membership event
+func (n *N) PublishNIP43MembershipEvent(kind int, pubkey []byte) error {
+	// This would require publishing an actual Nostr event
+	// For now, just log it
+	n.Logger.Infof("would publish NIP-43 event kind %d for %s", kind, hex.Enc(pubkey))
+	return nil
+}
+
+// addToMembersList adds a pubkey to the members list
+func (n *N) addToMembersList(pubkey []byte) error {
+	data, err := n.GetMarker("nip43_members_list")
+
+	var members []string
+	if err == nil {
+		if err := json.Unmarshal(data, &members); err != nil {
+			return fmt.Errorf("failed to unmarshal members list: %w", err)
+		}
+	}
+
+	hexPubkey := hex.Enc(pubkey)
+
+	// Check if already in list
+	for _, member := range members {
+		if member == hexPubkey {
+			return nil // Already in list
+		}
+	}
+
+	members = append(members, hexPubkey)
+
+	data, err = json.Marshal(members)
+	if err != nil {
+		return fmt.Errorf("failed to marshal members list: %w", err)
+	}
+
+	return n.SetMarker("nip43_members_list", data)
+}
+
+// removeFromMembersList removes a pubkey from the members list
+func (n *N) removeFromMembersList(pubkey []byte) error {
+	data, err := n.GetMarker("nip43_members_list")
+	if err != nil {
+		return nil // No list = nothing to remove
+	}
+
+	var members []string
+	if err := json.Unmarshal(data, &members); err != nil {
+		return fmt.Errorf("failed to unmarshal members list: %w", err)
+	}
+
+	hexPubkey := hex.Enc(pubkey)
+
+	// Filter out the pubkey
+	filtered := make([]string, 0, len(members))
+	for _, member := range members {
+		if member != hexPubkey {
+			filtered = append(filtered, member)
+		}
+	}
+
+	data, err = json.Marshal(filtered)
+	if err != nil {
+		return fmt.Errorf("failed to marshal members list: %w", err)
+	}
+
+	return n.SetMarker("nip43_members_list", data)
+}
--- a/pkg/neo4j/query-events.go
+++ b/pkg/neo4j/query-events.go
@@ -0,0 +1,480 @@
+package neo4j
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"next.orly.dev/pkg/database/indexes/types"
+	"next.orly.dev/pkg/encoders/event"
+	"next.orly.dev/pkg/encoders/filter"
+	"next.orly.dev/pkg/encoders/hex"
+	"next.orly.dev/pkg/encoders/tag"
+	"next.orly.dev/pkg/interfaces/store"
+)
+
+// QueryEvents retrieves events matching the given filter
+func (n *N) QueryEvents(c context.Context, f *filter.F) (evs event.S, err error) {
+	return n.QueryEventsWithOptions(c, f, false, false)
+}
+
+// QueryAllVersions retrieves all versions of events matching the filter
+func (n *N) QueryAllVersions(c context.Context, f *filter.F) (evs event.S, err error) {
+	return n.QueryEventsWithOptions(c, f, false, true)
+}
+
+// QueryEventsWithOptions retrieves events with specific options
+func (n *N) QueryEventsWithOptions(
+	c context.Context, f *filter.F, includeDeleteEvents bool, showAllVersions bool,
+) (evs event.S, err error) {
+	// Build Cypher query from Nostr filter
+	cypher, params := n.buildCypherQuery(f, includeDeleteEvents)
+
+	// Execute query
+	result, err := n.ExecuteRead(c, cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to execute query: %w", err)
+	}
+
+	// Parse response
+	evs, err = n.parseEventsFromResult(result)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse events: %w", err)
+	}
+
+	return evs, nil
+}
+
+// buildCypherQuery constructs a Cypher query from a Nostr filter
+// This is the core translation layer between Nostr's REQ filter format and Neo4j's Cypher
+func (n *N) buildCypherQuery(f *filter.F, includeDeleteEvents bool) (string, map[string]any) {
+	params := make(map[string]any)
+	var whereClauses []string
+
+	// Start with basic MATCH clause
+	matchClause := "MATCH (e:Event)"
+
+	// IDs filter - uses exact match or prefix matching
+	if len(f.Ids.T) > 0 {
+		idConditions := make([]string, len(f.Ids.T))
+		for i, id := range f.Ids.T {
+			paramName := fmt.Sprintf("id_%d", i)
+			hexID := hex.Enc(id)
+
+			// Handle prefix matching for partial IDs
+			if len(id) < 32 { // Full event ID is 32 bytes (64 hex chars)
+				idConditions[i] = fmt.Sprintf("e.id STARTS WITH $%s", paramName)
+			} else {
+				idConditions[i] = fmt.Sprintf("e.id = $%s", paramName)
+			}
+			params[paramName] = hexID
+		}
+		whereClauses = append(whereClauses, "("+strings.Join(idConditions, " OR ")+")")
+	}
+
+	// Authors filter - supports prefix matching for partial pubkeys
+	if len(f.Authors.T) > 0 {
+		authorConditions := make([]string, len(f.Authors.T))
+		for i, author := range f.Authors.T {
+			paramName := fmt.Sprintf("author_%d", i)
+			hexAuthor := hex.Enc(author)
+
+			// Handle prefix matching for partial pubkeys
+			if len(author) < 32 { // Full pubkey is 32 bytes (64 hex chars)
+				authorConditions[i] = fmt.Sprintf("e.pubkey STARTS WITH $%s", paramName)
+			} else {
+				authorConditions[i] = fmt.Sprintf("e.pubkey = $%s", paramName)
+			}
+			params[paramName] = hexAuthor
+		}
+		whereClauses = append(whereClauses, "("+strings.Join(authorConditions, " OR ")+")")
+	}
+
+	// Kinds filter - matches event types
+	if len(f.Kinds.K) > 0 {
+		kinds := make([]int64, len(f.Kinds.K))
+		for i, k := range f.Kinds.K {
+			kinds[i] = int64(k.K)
+		}
+		params["kinds"] = kinds
+		whereClauses = append(whereClauses, "e.kind IN $kinds")
+	}
+
+	// Time range filters - for temporal queries
+	if f.Since != nil {
+		params["since"] = f.Since.V
+		whereClauses = append(whereClauses, "e.created_at >= $since")
+	}
+	if f.Until != nil {
+		params["until"] = f.Until.V
+		whereClauses = append(whereClauses, "e.created_at <= $until")
+	}
+
+	// Tag filters - this is where Neo4j's graph capabilities shine
+	// We can efficiently traverse tag relationships
+	tagIndex := 0
+	for tagType, tagValues := range *f.Tags {
+		if len(tagValues.T) > 0 {
+			tagVarName := fmt.Sprintf("t%d", tagIndex)
+			tagTypeParam := fmt.Sprintf("tagType_%d", tagIndex)
+			tagValuesParam := fmt.Sprintf("tagValues_%d", tagIndex)
+
+			// Add tag relationship to MATCH clause
+			matchClause += fmt.Sprintf(" OPTIONAL MATCH (e)-[:TAGGED_WITH]->(%s:Tag)", tagVarName)
+
+			// Convert tag values to strings
+			tagValueStrings := make([]string, len(tagValues.T))
+			for i, tv := range tagValues.T {
+				tagValueStrings[i] = string(tv)
+			}
+
+			// Add WHERE conditions for this tag
+			params[tagTypeParam] = string(tagType)
+			params[tagValuesParam] = tagValueStrings
+			whereClauses = append(whereClauses,
+				fmt.Sprintf("(%s.type = $%s AND %s.value IN $%s)",
+					tagVarName, tagTypeParam, tagVarName, tagValuesParam))
+
+			tagIndex++
+		}
+	}
+
+	// Exclude delete events unless requested
+	if !includeDeleteEvents {
+		whereClauses = append(whereClauses, "e.kind <> 5")
+	}
+
+	// Build WHERE clause
+	whereClause := ""
+	if len(whereClauses) > 0 {
+		whereClause = " WHERE " + strings.Join(whereClauses, " AND ")
+	}
+
+	// Build RETURN clause with all event properties
+	returnClause := `
+RETURN e.id AS id,
+       e.kind AS kind,
+       e.created_at AS created_at,
+       e.content AS content,
+       e.sig AS sig,
+       e.pubkey AS pubkey,
+       e.tags AS tags,
+       e.serial AS serial`
+
+	// Add ordering (most recent first)
+	orderClause := " ORDER BY e.created_at DESC"
+
+	// Add limit if specified
+	limitClause := ""
+	if *f.Limit > 0 {
+		params["limit"] = *f.Limit
+		limitClause = " LIMIT $limit"
+	}
+
+	// Combine all parts
+	cypher := matchClause + whereClause + returnClause + orderClause + limitClause
+
+	return cypher, params
+}
+
+// parseEventsFromResult converts Neo4j query results to Nostr events
+func (n *N) parseEventsFromResult(result any) ([]*event.E, error) {
+	// Type assert to Neo4j result
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return nil, fmt.Errorf("invalid result type")
+	}
+
+	events := make([]*event.E, 0)
+	ctx := context.Background()
+
+	// Iterate through result records
+	for neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record == nil {
+			continue
+		}
+
+		// Extract fields from record
+		recordMap, ok := (*record).(map[string]any)
+		if !ok {
+			continue
+		}
+
+		// Parse event fields
+		idStr, _ := recordMap["id"].(string)
+		kind, _ := recordMap["kind"].(int64)
+		createdAt, _ := recordMap["created_at"].(int64)
+		content, _ := recordMap["content"].(string)
+		sigStr, _ := recordMap["sig"].(string)
+		pubkeyStr, _ := recordMap["pubkey"].(string)
+		tagsStr, _ := recordMap["tags"].(string)
+
+		// Decode hex strings
+		id, err := hex.Dec(idStr)
+		if err != nil {
+			continue
+		}
+		sig, err := hex.Dec(sigStr)
+		if err != nil {
+			continue
+		}
+		pubkey, err := hex.Dec(pubkeyStr)
+		if err != nil {
+			continue
+		}
+
+		// Parse tags from JSON
+		tags := tag.NewS()
+		if tagsStr != "" {
+			_ = tags.UnmarshalJSON([]byte(tagsStr))
+		}
+
+		// Create event
+		e := &event.E{
+			Kind:      uint16(kind),
+			CreatedAt: createdAt,
+			Content:   []byte(content),
+			Tags:      tags,
+		}
+
+		// Copy fixed-size arrays
+		copy(e.ID[:], id)
+		copy(e.Sig[:], sig)
+		copy(e.Pubkey[:], pubkey)
+
+		events = append(events, e)
+	}
+
+	if err := neo4jResult.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating results: %w", err)
+	}
+
+	return events, nil
+}
+
+// QueryDeleteEventsByTargetId retrieves delete events targeting a specific event ID
+func (n *N) QueryDeleteEventsByTargetId(c context.Context, targetEventId []byte) (
+	evs event.S, err error,
+) {
+	targetIDStr := hex.Enc(targetEventId)
+
+	// Query for kind 5 events that reference this event
+	// This uses Neo4j's graph traversal to find delete events
+	cypher := `
+MATCH (target:Event {id: $targetId})
+MATCH (e:Event {kind: 5})-[:REFERENCES]->(target)
+RETURN e.id AS id,
+       e.kind AS kind,
+       e.created_at AS created_at,
+       e.content AS content,
+       e.sig AS sig,
+       e.pubkey AS pubkey,
+       e.tags AS tags,
+       e.serial AS serial
+ORDER BY e.created_at DESC`
+
+	params := map[string]any{"targetId": targetIDStr}
+
+	result, err := n.ExecuteRead(c, cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query delete events: %w", err)
+	}
+
+	evs, err = n.parseEventsFromResult(result)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse delete events: %w", err)
+	}
+
+	return evs, nil
+}
+
+// QueryForSerials retrieves event serials matching a filter
+func (n *N) QueryForSerials(c context.Context, f *filter.F) (
+	serials types.Uint40s, err error,
+) {
+	// Build query but only return serial numbers
+	cypher, params := n.buildCypherQuery(f, false)
+
+	// Replace RETURN clause to only fetch serials
+	returnClause := " RETURN e.serial AS serial"
+	cypherParts := strings.Split(cypher, "RETURN")
+	if len(cypherParts) < 2 {
+		return nil, fmt.Errorf("invalid query structure")
+	}
+
+	// Rebuild query with serial-only return
+	cypher = cypherParts[0] + returnClause
+	if strings.Contains(cypherParts[1], "ORDER BY") {
+		orderPart := " ORDER BY" + strings.Split(cypherParts[1], "ORDER BY")[1]
+		cypher += orderPart
+	}
+
+	result, err := n.ExecuteRead(c, cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query serials: %w", err)
+	}
+
+	// Parse serials from result
+	serials = make([]*types.Uint40, 0)
+	ctx := context.Background()
+
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return nil, fmt.Errorf("invalid result type")
+	}
+
+	for neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record == nil {
+			continue
+		}
+
+		recordMap, ok := (*record).(map[string]any)
+		if !ok {
+			continue
+		}
+
+		serialVal, _ := recordMap["serial"].(int64)
+		serial := types.Uint40{}
+		serial.Set(uint64(serialVal))
+		serials = append(serials, &serial)
+	}
+
+	return serials, nil
+}
+
+// QueryForIds retrieves event IDs matching a filter
+func (n *N) QueryForIds(c context.Context, f *filter.F) (
+	idPkTs []*store.IdPkTs, err error,
+) {
+	// Build query but only return ID, pubkey, created_at, serial
+	cypher, params := n.buildCypherQuery(f, false)
+
+	// Replace RETURN clause
+	returnClause := `
+ RETURN e.id AS id,
+        e.pubkey AS pubkey,
+        e.created_at AS created_at,
+        e.serial AS serial`
+
+	cypherParts := strings.Split(cypher, "RETURN")
+	if len(cypherParts) < 2 {
+		return nil, fmt.Errorf("invalid query structure")
+	}
+
+	cypher = cypherParts[0] + returnClause
+	if strings.Contains(cypherParts[1], "ORDER BY") {
+		orderPart := " ORDER BY" + strings.Split(cypherParts[1], "ORDER BY")[1]
+		cypher += orderPart
+	}
+
+	result, err := n.ExecuteRead(c, cypher, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query IDs: %w", err)
+	}
+
+	// Parse IDs from result
+	idPkTs = make([]*store.IdPkTs, 0)
+	ctx := context.Background()
+
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return nil, fmt.Errorf("invalid result type")
+	}
+
+	for neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record == nil {
+			continue
+		}
+
+		recordMap, ok := (*record).(map[string]any)
+		if !ok {
+			continue
+		}
+
+		idStr, _ := recordMap["id"].(string)
+		pubkeyStr, _ := recordMap["pubkey"].(string)
+		createdAt, _ := recordMap["created_at"].(int64)
+		serialVal, _ := recordMap["serial"].(int64)
+
+		id, err := hex.Dec(idStr)
+		if err != nil {
+			continue
+		}
+		pubkey, err := hex.Dec(pubkeyStr)
+		if err != nil {
+			continue
+		}
+
+		idPkTs = append(idPkTs, &store.IdPkTs{
+			Id:  id,
+			Pub: pubkey,
+			Ts:  createdAt,
+			Ser: uint64(serialVal),
+		})
+	}
+
+	return idPkTs, nil
+}
+
+// CountEvents counts events matching a filter
+func (n *N) CountEvents(c context.Context, f *filter.F) (
+	count int, approximate bool, err error,
+) {
+	// Build query but only count results
+	cypher, params := n.buildCypherQuery(f, false)
+
+	// Replace RETURN clause with COUNT
+	returnClause := " RETURN count(e) AS count"
+	cypherParts := strings.Split(cypher, "RETURN")
+	if len(cypherParts) < 2 {
+		return 0, false, fmt.Errorf("invalid query structure")
+	}
+
+	// Remove ORDER BY and LIMIT for count query
+	cypher = cypherParts[0] + returnClause
+	delete(params, "limit") // Remove limit parameter if it exists
+
+	result, err := n.ExecuteRead(c, cypher, params)
+	if err != nil {
+		return 0, false, fmt.Errorf("failed to count events: %w", err)
+	}
+
+	// Parse count from result
+	ctx := context.Background()
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return 0, false, fmt.Errorf("invalid result type")
+	}
+
+	if neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record != nil {
+			recordMap, ok := (*record).(map[string]any)
+			if ok {
+				countVal, _ := recordMap["count"].(int64)
+				count = int(countVal)
+			}
+		}
+	}
+
+	return count, false, nil
+}
--- a/pkg/neo4j/save-event.go
+++ b/pkg/neo4j/save-event.go
@@ -0,0 +1,266 @@
+package neo4j
+
+import (
+	"context"
+	"fmt"
+
+	"next.orly.dev/pkg/database/indexes/types"
+	"next.orly.dev/pkg/encoders/event"
+	"next.orly.dev/pkg/encoders/filter"
+	"next.orly.dev/pkg/encoders/hex"
+)
+
+// SaveEvent stores a Nostr event in the Neo4j database.
+// It creates event nodes and relationships for authors, tags, and references.
+// This method leverages Neo4j's graph capabilities to model Nostr's social graph naturally.
+func (n *N) SaveEvent(c context.Context, ev *event.E) (exists bool, err error) {
+	eventID := hex.Enc(ev.ID[:])
+
+	// Check if event already exists
+	checkCypher := "MATCH (e:Event {id: $id}) RETURN e.id AS id"
+	checkParams := map[string]any{"id": eventID}
+
+	result, err := n.ExecuteRead(c, checkCypher, checkParams)
+	if err != nil {
+		return false, fmt.Errorf("failed to check event existence: %w", err)
+	}
+
+	// Check if we got a result
+	ctx := context.Background()
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if ok && neo4jResult.Next(ctx) {
+		return true, nil // Event already exists
+	}
+
+	// Get next serial number
+	serial, err := n.getNextSerial()
+	if err != nil {
+		return false, fmt.Errorf("failed to get serial number: %w", err)
+	}
+
+	// Build and execute Cypher query to create event with all relationships
+	cypher, params := n.buildEventCreationCypher(ev, serial)
+
+	if _, err = n.ExecuteWrite(c, cypher, params); err != nil {
+		return false, fmt.Errorf("failed to save event: %w", err)
+	}
+
+	return false, nil
+}
+
+// buildEventCreationCypher constructs a Cypher query to create an event node with all relationships
+// This is a single atomic operation that creates:
+// - Event node with all properties
+// - Author node and AUTHORED_BY relationship
+// - Tag nodes and TAGGED_WITH relationships
+// - Reference relationships (REFERENCES for 'e' tags, MENTIONS for 'p' tags)
+func (n *N) buildEventCreationCypher(ev *event.E, serial uint64) (string, map[string]any) {
+	params := make(map[string]any)
+
+	// Event properties
+	eventID := hex.Enc(ev.ID[:])
+	authorPubkey := hex.Enc(ev.Pubkey[:])
+
+	params["eventId"] = eventID
+	params["serial"] = serial
+	params["kind"] = int64(ev.Kind)
+	params["createdAt"] = ev.CreatedAt
+	params["content"] = string(ev.Content)
+	params["sig"] = hex.Enc(ev.Sig[:])
+	params["pubkey"] = authorPubkey
+
+	// Serialize tags as JSON string for storage
+	tagsJSON, _ := ev.Tags.MarshalJSON()
+	params["tags"] = string(tagsJSON)
+
+	// Start building the Cypher query
+	// Use MERGE to ensure idempotency for author nodes
+	cypher := `
+// Create or match author node
+MERGE (a:Author {pubkey: $pubkey})
+
+// Create event node
+CREATE (e:Event {
+  id: $eventId,
+  serial: $serial,
+  kind: $kind,
+  created_at: $createdAt,
+  content: $content,
+  sig: $sig,
+  pubkey: $pubkey,
+  tags: $tags
+})
+
+// Link event to author
+CREATE (e)-[:AUTHORED_BY]->(a)
+`
+
+	// Process tags to create relationships
+	// Different tag types create different relationship patterns
+	tagNodeIndex := 0
+	eTagIndex := 0
+	pTagIndex := 0
+
+	for _, tagItem := range *ev.Tags {
+		if len(tagItem.T) < 2 {
+			continue
+		}
+
+		tagType := string(tagItem.T[0])
+		tagValue := string(tagItem.T[1])
+
+		switch tagType {
+		case "e": // Event reference - creates REFERENCES relationship
+			// Create reference to another event (if it exists)
+			paramName := fmt.Sprintf("eTag_%d", eTagIndex)
+			params[paramName] = tagValue
+
+			cypher += fmt.Sprintf(`
+// Reference to event (e-tag)
+OPTIONAL MATCH (ref%d:Event {id: $%s})
+FOREACH (ignoreMe IN CASE WHEN ref%d IS NOT NULL THEN [1] ELSE [] END |
+  CREATE (e)-[:REFERENCES]->(ref%d)
+)
+`, eTagIndex, paramName, eTagIndex, eTagIndex)
+
+			eTagIndex++
+
+		case "p": // Pubkey mention - creates MENTIONS relationship
+			// Create mention to another author
+			paramName := fmt.Sprintf("pTag_%d", pTagIndex)
+			params[paramName] = tagValue
+
+			cypher += fmt.Sprintf(`
+// Mention of author (p-tag)
+MERGE (mentioned%d:Author {pubkey: $%s})
+CREATE (e)-[:MENTIONS]->(mentioned%d)
+`, pTagIndex, paramName, pTagIndex)
+
+			pTagIndex++
+
+		default: // Other tags - creates Tag nodes and TAGGED_WITH relationships
+			// Create tag node and relationship
+			typeParam := fmt.Sprintf("tagType_%d", tagNodeIndex)
+			valueParam := fmt.Sprintf("tagValue_%d", tagNodeIndex)
+			params[typeParam] = tagType
+			params[valueParam] = tagValue
+
+			cypher += fmt.Sprintf(`
+// Generic tag relationship
+MERGE (tag%d:Tag {type: $%s, value: $%s})
+CREATE (e)-[:TAGGED_WITH]->(tag%d)
+`, tagNodeIndex, typeParam, valueParam, tagNodeIndex)
+
+			tagNodeIndex++
+		}
+	}
+
+	// Return the created event
+	cypher += `
+RETURN e.id AS id`
+
+	return cypher, params
+}
+
+// GetSerialsFromFilter returns event serials matching a filter
+func (n *N) GetSerialsFromFilter(f *filter.F) (serials types.Uint40s, err error) {
+	// Use QueryForSerials with background context
+	return n.QueryForSerials(context.Background(), f)
+}
+
+// WouldReplaceEvent checks if an event would replace existing events
+// This handles replaceable events (kinds 0, 3, and 10000-19999)
+// and parameterized replaceable events (kinds 30000-39999)
+func (n *N) WouldReplaceEvent(ev *event.E) (bool, types.Uint40s, error) {
+	// Check for replaceable events (kinds 0, 3, and 10000-19999)
+	isReplaceable := ev.Kind == 0 || ev.Kind == 3 || (ev.Kind >= 10000 && ev.Kind < 20000)
+
+	// Check for parameterized replaceable events (kinds 30000-39999)
+	isParameterizedReplaceable := ev.Kind >= 30000 && ev.Kind < 40000
+
+	if !isReplaceable && !isParameterizedReplaceable {
+		return false, nil, nil
+	}
+
+	authorPubkey := hex.Enc(ev.Pubkey[:])
+	ctx := context.Background()
+
+	var cypher string
+	params := map[string]any{
+		"pubkey":    authorPubkey,
+		"kind":      int64(ev.Kind),
+		"createdAt": ev.CreatedAt,
+	}
+
+	if isParameterizedReplaceable {
+		// For parameterized replaceable events, we need to match on d-tag as well
+		dTag := ev.Tags.GetFirst([]byte{'d'})
+		if dTag == nil {
+			return false, nil, nil
+		}
+
+		dValue := ""
+		if len(dTag.T) >= 2 {
+			dValue = string(dTag.T[1])
+		}
+
+		params["dValue"] = dValue
+
+		// Query for existing parameterized replaceable events with same kind, pubkey, and d-tag
+		cypher = `
+MATCH (e:Event {kind: $kind, pubkey: $pubkey})-[:TAGGED_WITH]->(t:Tag {type: 'd', value: $dValue})
+WHERE e.created_at < $createdAt
+RETURN e.serial AS serial, e.created_at AS created_at
+ORDER BY e.created_at DESC`
+
+	} else {
+		// Query for existing replaceable events with same kind and pubkey
+		cypher = `
+MATCH (e:Event {kind: $kind, pubkey: $pubkey})
+WHERE e.created_at < $createdAt
+RETURN e.serial AS serial, e.created_at AS created_at
+ORDER BY e.created_at DESC`
+	}
+
+	result, err := n.ExecuteRead(ctx, cypher, params)
+	if err != nil {
+		return false, nil, fmt.Errorf("failed to query replaceable events: %w", err)
+	}
+
+	// Parse results
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return false, nil, fmt.Errorf("invalid result type")
+	}
+
+	var serials types.Uint40s
+	wouldReplace := false
+
+	for neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record == nil {
+			continue
+		}
+
+		recordMap, ok := (*record).(map[string]any)
+		if !ok {
+			continue
+		}
+
+		serialVal, _ := recordMap["serial"].(int64)
+		wouldReplace = true
+		serial := types.Uint40{}
+		serial.Set(uint64(serialVal))
+		serials = append(serials, &serial)
+	}
+
+	return wouldReplace, serials, nil
+}
--- a/pkg/neo4j/schema.go
+++ b/pkg/neo4j/schema.go
@@ -0,0 +1,108 @@
+package neo4j
+
+import (
+	"context"
+	"fmt"
+)
+
+// applySchema creates Neo4j constraints and indexes for Nostr events
+// Neo4j uses Cypher queries to define schema constraints and indexes
+func (n *N) applySchema(ctx context.Context) error {
+	n.Logger.Infof("applying Nostr schema to neo4j")
+
+	// Create constraints and indexes using Cypher queries
+	// Constraints ensure uniqueness and are automatically indexed
+	constraints := []string{
+		// Unique constraint on Event.id (event ID must be unique)
+		"CREATE CONSTRAINT event_id_unique IF NOT EXISTS FOR (e:Event) REQUIRE e.id IS UNIQUE",
+
+		// Unique constraint on Author.pubkey (author public key must be unique)
+		"CREATE CONSTRAINT author_pubkey_unique IF NOT EXISTS FOR (a:Author) REQUIRE a.pubkey IS UNIQUE",
+
+		// Unique constraint on Marker.key (marker key must be unique)
+		"CREATE CONSTRAINT marker_key_unique IF NOT EXISTS FOR (m:Marker) REQUIRE m.key IS UNIQUE",
+	}
+
+	// Additional indexes for query optimization
+	indexes := []string{
+		// Index on Event.kind for kind-based queries
+		"CREATE INDEX event_kind IF NOT EXISTS FOR (e:Event) ON (e.kind)",
+
+		// Index on Event.created_at for time-range queries
+		"CREATE INDEX event_created_at IF NOT EXISTS FOR (e:Event) ON (e.created_at)",
+
+		// Index on Event.serial for serial-based lookups
+		"CREATE INDEX event_serial IF NOT EXISTS FOR (e:Event) ON (e.serial)",
+
+		// Composite index for common query patterns (kind + created_at)
+		"CREATE INDEX event_kind_created_at IF NOT EXISTS FOR (e:Event) ON (e.kind, e.created_at)",
+
+		// Index on Tag.type for tag-type queries
+		"CREATE INDEX tag_type IF NOT EXISTS FOR (t:Tag) ON (t.type)",
+
+		// Index on Tag.value for tag-value queries
+		"CREATE INDEX tag_value IF NOT EXISTS FOR (t:Tag) ON (t.value)",
+
+		// Composite index for tag queries (type + value)
+		"CREATE INDEX tag_type_value IF NOT EXISTS FOR (t:Tag) ON (t.type, t.value)",
+	}
+
+	// Execute all constraint creation queries
+	for _, constraint := range constraints {
+		if _, err := n.ExecuteWrite(ctx, constraint, nil); err != nil {
+			return fmt.Errorf("failed to create constraint: %w", err)
+		}
+	}
+
+	// Execute all index creation queries
+	for _, index := range indexes {
+		if _, err := n.ExecuteWrite(ctx, index, nil); err != nil {
+			return fmt.Errorf("failed to create index: %w", err)
+		}
+	}
+
+	n.Logger.Infof("schema applied successfully")
+	return nil
+}
+
+// dropAll drops all data from neo4j (useful for testing)
+func (n *N) dropAll(ctx context.Context) error {
+	n.Logger.Warningf("dropping all data from neo4j")
+
+	// Delete all nodes and relationships
+	_, err := n.ExecuteWrite(ctx, "MATCH (n) DETACH DELETE n", nil)
+	if err != nil {
+		return fmt.Errorf("failed to drop all data: %w", err)
+	}
+
+	// Drop all constraints
+	constraints := []string{
+		"DROP CONSTRAINT event_id_unique IF EXISTS",
+		"DROP CONSTRAINT author_pubkey_unique IF EXISTS",
+		"DROP CONSTRAINT marker_key_unique IF EXISTS",
+	}
+
+	for _, constraint := range constraints {
+		_, _ = n.ExecuteWrite(ctx, constraint, nil)
+		// Ignore errors as constraints may not exist
+	}
+
+	// Drop all indexes
+	indexes := []string{
+		"DROP INDEX event_kind IF EXISTS",
+		"DROP INDEX event_created_at IF EXISTS",
+		"DROP INDEX event_serial IF EXISTS",
+		"DROP INDEX event_kind_created_at IF EXISTS",
+		"DROP INDEX tag_type IF EXISTS",
+		"DROP INDEX tag_value IF EXISTS",
+		"DROP INDEX tag_type_value IF EXISTS",
+	}
+
+	for _, index := range indexes {
+		_, _ = n.ExecuteWrite(ctx, index, nil)
+		// Ignore errors as indexes may not exist
+	}
+
+	// Reapply schema after dropping
+	return n.applySchema(ctx)
+}
--- a/pkg/neo4j/serial.go
+++ b/pkg/neo4j/serial.go
@@ -0,0 +1,113 @@
+package neo4j
+
+import (
+	"context"
+	"fmt"
+	"sync"
+)
+
+// Serial number management
+// We use a special Marker node in Neo4j to track the next available serial number
+
+const serialCounterKey = "serial_counter"
+
+var (
+	serialMutex sync.Mutex
+)
+
+// getNextSerial atomically increments and returns the next serial number
+func (n *N) getNextSerial() (uint64, error) {
+	serialMutex.Lock()
+	defer serialMutex.Unlock()
+
+	ctx := context.Background()
+
+	// Query current serial value
+	cypher := "MATCH (m:Marker {key: $key}) RETURN m.value AS value"
+	params := map[string]any{"key": serialCounterKey}
+
+	result, err := n.ExecuteRead(ctx, cypher, params)
+	if err != nil {
+		return 0, fmt.Errorf("failed to query serial counter: %w", err)
+	}
+
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if !ok {
+		return 1, nil
+	}
+
+	var currentSerial uint64 = 1
+	if neo4jResult.Next(ctx) {
+		record := neo4jResult.Record()
+		if record != nil {
+			recordMap, ok := (*record).(map[string]any)
+			if ok {
+				if value, ok := recordMap["value"].(int64); ok {
+					currentSerial = uint64(value)
+				}
+			}
+		}
+	}
+
+	// Increment serial
+	nextSerial := currentSerial + 1
+
+	// Update counter
+	updateCypher := `
+MERGE (m:Marker {key: $key})
+SET m.value = $value`
+	updateParams := map[string]any{
+		"key":   serialCounterKey,
+		"value": int64(nextSerial),
+	}
+
+	_, err = n.ExecuteWrite(ctx, updateCypher, updateParams)
+	if err != nil {
+		return 0, fmt.Errorf("failed to update serial counter: %w", err)
+	}
+
+	return currentSerial, nil
+}
+
+// initSerialCounter initializes the serial counter if it doesn't exist
+func (n *N) initSerialCounter() error {
+	ctx := context.Background()
+
+	// Check if counter exists
+	cypher := "MATCH (m:Marker {key: $key}) RETURN m.value AS value"
+	params := map[string]any{"key": serialCounterKey}
+
+	result, err := n.ExecuteRead(ctx, cypher, params)
+	if err != nil {
+		return fmt.Errorf("failed to check serial counter: %w", err)
+	}
+
+	neo4jResult, ok := result.(interface {
+		Next(context.Context) bool
+		Record() *interface{}
+		Err() error
+	})
+	if ok && neo4jResult.Next(ctx) {
+		// Counter already exists
+		return nil
+	}
+
+	// Initialize counter at 1
+	initCypher := "CREATE (m:Marker {key: $key, value: $value})"
+	initParams := map[string]any{
+		"key":   serialCounterKey,
+		"value": int64(1),
+	}
+
+	_, err = n.ExecuteWrite(ctx, initCypher, initParams)
+	if err != nil {
+		return fmt.Errorf("failed to initialize serial counter: %w", err)
+	}
+
+	n.Logger.Infof("initialized serial counter")
+	return nil
+}
--- a/pkg/neo4j/subscriptions.go
+++ b/pkg/neo4j/subscriptions.go
@@ -0,0 +1,181 @@
+package neo4j
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"next.orly.dev/pkg/database"
+	"next.orly.dev/pkg/encoders/hex"
+)
+
+// Subscription and payment methods
+// Simplified implementation using marker-based storage via Badger
+// For production graph-based storage, these could use Neo4j nodes with relationships
+
+// GetSubscription retrieves subscription information for a pubkey
+func (n *N) GetSubscription(pubkey []byte) (*database.Subscription, error) {
+	key := "sub_" + hex.Enc(pubkey)
+	data, err := n.GetMarker(key)
+	if err != nil {
+		return nil, err
+	}
+
+	var sub database.Subscription
+	if err := json.Unmarshal(data, &sub); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal subscription: %w", err)
+	}
+
+	return &sub, nil
+}
+
+// IsSubscriptionActive checks if a pubkey has an active subscription
+func (n *N) IsSubscriptionActive(pubkey []byte) (bool, error) {
+	sub, err := n.GetSubscription(pubkey)
+	if err != nil {
+		return false, nil // No subscription = not active
+	}
+
+	return sub.PaidUntil.After(time.Now()), nil
+}
+
+// ExtendSubscription extends a subscription by the specified number of days
+func (n *N) ExtendSubscription(pubkey []byte, days int) error {
+	key := "sub_" + hex.Enc(pubkey)
+
+	// Get existing subscription or create new
+	var sub database.Subscription
+	data, err := n.GetMarker(key)
+	if err == nil {
+		if err := json.Unmarshal(data, &sub); err != nil {
+			return fmt.Errorf("failed to unmarshal subscription: %w", err)
+		}
+	} else {
+		// New subscription - set trial period
+		sub.TrialEnd = time.Now()
+		sub.PaidUntil = time.Now()
+	}
+
+	// Extend expiration
+	if sub.PaidUntil.Before(time.Now()) {
+		sub.PaidUntil = time.Now()
+	}
+	sub.PaidUntil = sub.PaidUntil.Add(time.Duration(days) * 24 * time.Hour)
+
+	// Save
+	data, err = json.Marshal(sub)
+	if err != nil {
+		return fmt.Errorf("failed to marshal subscription: %w", err)
+	}
+
+	return n.SetMarker(key, data)
+}
+
+// RecordPayment records a payment for subscription extension
+func (n *N) RecordPayment(
+	pubkey []byte, amount int64, invoice, preimage string,
+) error {
+	// Store payment in payments list
+	key := "payments_" + hex.Enc(pubkey)
+
+	var payments []database.Payment
+	data, err := n.GetMarker(key)
+	if err == nil {
+		if err := json.Unmarshal(data, &payments); err != nil {
+			return fmt.Errorf("failed to unmarshal payments: %w", err)
+		}
+	}
+
+	payment := database.Payment{
+		Amount:    amount,
+		Timestamp: time.Now(),
+		Invoice:   invoice,
+		Preimage:  preimage,
+	}
+
+	payments = append(payments, payment)
+
+	data, err = json.Marshal(payments)
+	if err != nil {
+		return fmt.Errorf("failed to marshal payments: %w", err)
+	}
+
+	return n.SetMarker(key, data)
+}
+
+// GetPaymentHistory retrieves payment history for a pubkey
+func (n *N) GetPaymentHistory(pubkey []byte) ([]database.Payment, error) {
+	key := "payments_" + hex.Enc(pubkey)
+
+	data, err := n.GetMarker(key)
+	if err != nil {
+		return nil, nil // No payments = empty list
+	}
+
+	var payments []database.Payment
+	if err := json.Unmarshal(data, &payments); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal payments: %w", err)
+	}
+
+	return payments, nil
+}
+
+// ExtendBlossomSubscription extends a Blossom storage subscription
+func (n *N) ExtendBlossomSubscription(
+	pubkey []byte, tier string, storageMB int64, daysExtended int,
+) error {
+	key := "blossom_" + hex.Enc(pubkey)
+
+	// Simple implementation - just store tier and expiry
+	data := map[string]interface{}{
+		"tier":      tier,
+		"storageMB": storageMB,
+		"extended":  daysExtended,
+		"updated":   time.Now(),
+	}
+
+	jsonData, err := json.Marshal(data)
+	if err != nil {
+		return fmt.Errorf("failed to marshal blossom subscription: %w", err)
+	}
+
+	return n.SetMarker(key, jsonData)
+}
+
+// GetBlossomStorageQuota retrieves the storage quota for a pubkey
+func (n *N) GetBlossomStorageQuota(pubkey []byte) (quotaMB int64, err error) {
+	key := "blossom_" + hex.Enc(pubkey)
+
+	data, err := n.GetMarker(key)
+	if err != nil {
+		return 0, nil // No subscription = 0 quota
+	}
+
+	var subData map[string]interface{}
+	if err := json.Unmarshal(data, &subData); err != nil {
+		return 0, fmt.Errorf("failed to unmarshal blossom data: %w", err)
+	}
+
+	if storageMB, ok := subData["storageMB"].(float64); ok {
+		return int64(storageMB), nil
+	}
+
+	return 0, nil
+}
+
+// IsFirstTimeUser checks if this is the first time a user is accessing the relay
+func (n *N) IsFirstTimeUser(pubkey []byte) (bool, error) {
+	key := "first_seen_" + hex.Enc(pubkey)
+
+	// If marker exists, not first time
+	if n.HasMarker(key) {
+		return false, nil
+	}
+
+	// Mark as seen
+	if err := n.SetMarker(key, []byte{1}); err != nil {
+		return true, err
+	}
+
+	return true, nil
+}
--- a/pkg/neo4j/testmain_test.go
+++ b/pkg/neo4j/testmain_test.go
@@ -0,0 +1,15 @@
+package neo4j
+
+import (
+	"os"
+	"testing"
+)
+
+// skipIfNeo4jNotAvailable skips the test if Neo4j is not available
+func skipIfNeo4jNotAvailable(t *testing.T) {
+	// Check if Neo4j connection details are provided
+	uri := os.Getenv("ORLY_NEO4J_URI")
+	if uri == "" {
+		t.Skip("Neo4j not available (set ORLY_NEO4J_URI to enable tests)")
+	}
+}
--- a/pkg/version/version
+++ b/pkg/version/version
@@ -1 +1 @@
-v0.29.2
+v0.29.3
Author	SHA1	Message	Date
mleku	d5c0e3abfc	bump to v0.29.3 Some checks failed Go / build (push) Has been cancelled Details Go / release (push) Has been cancelled Details	2025-11-18 18:22:39 +00:00
mleku	1d4d877a10	fix auth-required not sending immediate challenge, benchmark leak	2025-11-18 18:21:11 +00:00
mleku	038d1959ed	add dgraph backend to benchmark suite with safe type assertions for multi-backend support	2025-11-17 16:52:38 +00:00
mleku	86481a42e8	initial draft of neo4j database driver	2025-11-17 08:19:44 +00:00