Case Studies Page — Nebula DB Architecture Deep-Dive

// main.js
const CASE_STUDY = {
  projectName: "Nebula DB",
  thesis: "Building a write-optimized distributed key-value store from scratch in Rust.",
  tech: ["Rust", "Tokio", "LMDB", "gRPC", "Docker"],
  sections: [
    {
      id: "problem",
      heading: "Problem",
      content: `Existing key-value stores in the team's stack were tuned for read-heavy workloads.
        Under write amplification from the analytics pipeline, p99 latency spiked past 400 ms.
        We needed a purpose-built store that could absorb burst writes without sacrificing read consistency.`,
    },
    {
      id: "goal",
      heading: "Goal",
      content: `Achieve sub-10 ms p99 write latency at 50,000 writes/second on commodity hardware,
        with a Redis-compatible client interface so the existing application layer needed no changes.`,
    },
    {
      id: "process",
      heading: "Process",
      content: `Started with a spike in Go to validate the protocol layer, then pivoted to Rust after
        benchmarking showed a 3× throughput advantage. Iterated through three storage engine designs
        before settling on an LMDB backend with a custom write-ahead log.`,
    },
    {
      id: "design-decisions",
      heading: "Design Decisions",
      content: `Chose gRPC over REST for internal service communication to reduce serialization overhead.
        Kept the client-facing API Redis-compatible to avoid a migration burden. Decided against
        a leader-election consensus algorithm in v1 to reduce operational complexity.`,
    },
    {
      id: "dev-decisions",
      heading: "Dev Decisions",
      content: `Tokio async runtime handled the connection pool. Unsafe Rust was used in exactly two
        places — both profiled and documented with safety invariants. The Docker image was kept under
        18 MB by building a statically linked binary against musl libc.`,
    },
    {
      id: "result",
      heading: "Result",
      content: `Shipped to staging after 11 weeks. p99 write latency dropped to 7 ms at 50k writes/sec.
        The Redis-compatible interface meant zero application-layer changes. Identified two improvements
        for v2: a proper replication protocol and a Prometheus metrics endpoint.`,
    },
  ],
};

// main.js — sticky sidebar
function CaseStudySidebar({ sections, activeId }) {
  return (
    <nav className="case-study-sidebar">
      {sections.map((section) => (
        <a
          key={section.id}
          href={`#${section.id}`}
          className={activeId === section.id ? "sidebar-link active" : "sidebar-link"}
        >
          {section.heading}
        </a>
      ))}
    </nav>
  );
}