Skip to main content

Getting Started with Prism

Read time: 5 minutes

What is Prism?​

Prism is a data access gateway that sits between your applications and data backends (Kafka, PostgreSQL, Redis, NATS). It provides:

  • Single API for all data operations
  • Automatic reliability patterns (no manual implementation)
  • Backend flexibility (swap backends without code changes)
  • Built-in observability and security

The Problem Prism Solves​

Before Prism:

Your App → Kafka (for events)
        → PostgreSQL (for transactions)
        → Redis (for caching)
        → Manual implementation of:
          - Retry logic
          - Circuit breakers
          - Data validation
          - PII handling
          - Monitoring

Result: Complex application code, tight backend coupling, repeated reliability patterns.

With Prism:

Your App → Prism → [Kafka | PostgreSQL | Redis | NATS]

Prism handles:
  ✓ Reliability patterns automatically
  ✓ Backend connections and failover
  ✓ Security and compliance
  ✓ Monitoring and observability

Result: Simple application code, backend independence, zero boilerplate.

Quick Value Comparison​

TaskWithout PrismWith Prism
Add message queue2-3 days (provision Kafka, write producer/consumer, add retry logic, monitoring)30 minutes (request namespace, use provided API)
Ensure no data lossWrite WAL pattern, test crash scenarios, maintain codeEnable durability: strong in config
Switch backendsRewrite application code, test thoroughlyUpdate platform config, zero app changes
Handle PIIManual encryption, log masking, audit trailsAdd (prism.pii) annotation
Migrate dataManual dual-write, complex cutoverEnable shadow traffic, automatic migration

Core Concept: Three Layers​

Prism separates concerns into three layers you never directly configure:

┌─────────────────────┐
│ What: Client API    │  You declare: "I need a queue"
└─────────────────────┘
         ↓
┌─────────────────────┐
│ How: Patterns       │  Prism applies: Durability, Retry
└─────────────────────┘
         ↓
┌─────────────────────┐
│ Where: Backends     │  Prism uses: Kafka + PostgreSQL
└─────────────────────┘

You control: What you need (queue, key-value store, event stream) Prism controls: How it works (patterns) and where data lives (backends)

Your First Namespace​

Step 1: Declare your needs

namespace: user-events
team: analytics

client_api: pubsub  # Event publishing and subscription

needs:
  write_rps: 1000        # 1K writes per second
  retention: 7days       # Keep events for a week
  durability: strong     # Don't lose events

Step 2: Submit request

prism namespace create user-events.yaml

Step 3: Use the API

# Publish events
prism.publish("user-events", {"user_id": 123, "action": "login"})

# Subscribe to events
for event in prism.subscribe("user-events"):
    process(event)

That's it. Prism provisions Kafka, applies durability patterns, configures monitoring.

Key Benefits​

1. Fast Time to Value​

Traditional: Weeks to provision, configure, test backends Prism: 30 minutes from request to production

2. Zero Backend Lock-In​

Start with NATS (lightweight), scale to Kafka (high throughput), zero code changes.

3. Automatic Reliability​

WAL (Write-Ahead Log), retry logic, circuit breakers—all built-in.

4. Team Self-Service​

Application teams request namespaces, platform team sets guardrails.

5. Production-Grade Operations​

Observability, security, compliance—included by default.

When to Use Prism​

Use Prism when you need:

  • ✅ Message queues or event streams
  • ✅ Key-value data storage
  • ✅ Publish-subscribe messaging
  • ✅ Strong durability guarantees
  • ✅ Backend migration flexibility
  • ✅ Team self-service data access

Skip Prism when you need:

  • ❌ Direct SQL queries with complex joins (use database directly)
  • ❌ Sub-millisecond latency requirements (use local cache)
  • ❌ Backend-specific features not exposed via Prism APIs

Performance​

Prism is built in Rust for extreme performance:

  • Latency: P50 <1ms, P99 <10ms
  • Throughput: 200K+ requests per second per instance
  • Memory: 20MB idle, scales linearly with connections

Comparison to JVM alternatives: 10-100x faster, 20x less memory.

Next Steps​

  1. Understand Core Concepts - Learn the three-layer architecture
  2. Request Your First Namespace - Step-by-step guide
  3. Choose Data Patterns - Match patterns to use cases

Getting Help​