Blackwell Systems

About

Dayna Blackwell builds reliable distributed systems at scale.

I’m a software architect specializing in event-driven architectures at scale. Currently, I design and operate the global loyalty and promotions platform for a major hospitality brand - the backend services powering rewards programs, digital wallets, and promotional campaigns used by millions of customers worldwide.

My work focuses on making distributed systems predictable: idempotent message handling, content-based deduplication, selective semantic hashing, and observability patterns that make production failures understandable when they happen. The goal is systems where 3 AM pages are rare and debuggable.

The tech stack spans AWS (Lambda, EventBridge, DynamoDB, Step Functions, ECR, VPC networking, Glue, Redshift), backend services (Python FastAPI, Java Jakarta EE, Go microservices), infrastructure-as-code (CDK, Terraform), and Rust for performance-critical components. Deep AWS expertise across compute, networking, orchestration, and data layers. My career path - from operations leadership through backend architecture - shapes how I think about systems: they have to work for the people maintaining them at 3 AM, not just the people designing them at 3 PM.

What I Write About

This blog provides comprehensive technical deep-dives into programming language fundamentals and distributed systems architecture. I write to build strong mental models - the kind you can’t get from framework documentation or tutorials.

Language Design & Mental Models:

  • Value semantics vs reference semantics (Go, Rust vs Python, Java)
  • Why modern languages moved away from OOP patterns
  • Memory models, concurrency primitives, and performance implications
  • Cache locality, stack vs heap, escape analysis
  • Building strong mental models through polyglot comparison

Distributed Systems:

  • Event-driven architectures at scale
  • Idempotent message handling and deduplication patterns
  • Observability and debugging production failures
  • Serverless patterns and AWS architecture
  • API design (REST, GraphQL, WebSocket, gRPC)

Developer Tools:

  • Claude Code workflows and AI-assisted development
  • Secret management and security patterns
  • Structured error handling across frameworks
  • Open source library design

These articles are the ones I wish existed when I was learning: comprehensive (5,000+ words is common), visual (Mermaid diagrams throughout), and focused on the “why” rather than the “how.”

Recent Articles

Polyglot Programming Philosophy

As a polyglot programmer (Python, Java, Go, Rust), I approach each language by building strong mental models: understanding why Go treats everything as a value, why Python makes everything an object, why Rust enforces ownership. Polyglot programming forces you to confront the underlying implementations and low-level details of each language - when something you’re used to “just working” in one language completely breaks in another, you can’t stay at the surface level anymore.

Each language represents a fundamentally different way of thinking about memory, concurrency, and composition. This cross-language perspective shapes how I design systems and choose the right tool for each problem. Seeing the same concept across multiple languages reveals the tradeoffs behind each design decision - from memory models and type systems to the low-level implementation details that determine whether your architecture survives production.

Open Source & Technical Writing

Outside the Python/Java enterprise world, I build cloud-native infrastructure and developer tools in Go and Rust. My open source work includes a C library for detecting structural memory leaks invisible to conventional tools (libdrainprof), a language-agnostic Kubernetes secrets control plane (vaultmux-server), a complete GCP emulator ecosystem for local testing (Secret Manager, IAM, KMS, control plane), build-time schema compilation from Go to TypeScript (goldenthread), unified secret management across multiple vault backends (vaultmux, vaultmux-rs), profile management for Claude Code (dotclaude), type-safe validation with automatic TypeScript schema generation (domainstack), and structured error handling that works across different web frameworks (error-envelope, err-envelope).

As a technical writer (3x AWS Certified, 225,000+ lines of documentation), I’ve authored You Don’t Know JSON (127,000 words) - a comprehensive guide to JSON’s ecosystem: from schema validation to binary formats (MessagePack, CBOR, Protocol Buffers), streaming architectures, security patterns, API design, data pipelines, and testing strategies. Learn when JSON works, when it doesn’t, and what to use instead.

Books

You Don’t Know JSON - A comprehensive guide to JSON’s ecosystem: from schema validation to binary formats (MessagePack, CBOR, Protocol Buffers), streaming architectures, security patterns, API design, data pipelines, and testing strategies. Learn when JSON works, when it doesn’t, and what to use instead. Available on Leanpub.

Publications

Blackwell, D. (2026). Normalization Confluence in Federated Registry Networks. Technical Report.
doi:10.5281/zenodo.18677400

Extends normalization confluence to federated environments where multiple registries with independent invariants are connected by morphisms encoding cross-organizational constraints. For tree-shaped morphism networks, proves federated convergence requires only validity preservation - all other conditions derive from network acyclicity via an authority argument. Includes self-contained treatment of single-registry model with convergence theorem, necessity results, and verification calculus.

Blackwell, D. (2026). Normalization Confluence for Registry-Governed Stream Processing. Technical Report.
doi:10.5281/zenodo.18671870

Identifies a third regime for coordination-free convergence in distributed systems: normalization confluence, where non-commutative operations that may violate invariants converge through compensation. Formalizes registry-governed stream processing, proves termination and confluence under well-founded compensation (WFC) and compensation commutativity (CC), and develops a verification calculus for practical CC checking. Shows uniformly bounded compensation (UBC) yields constant per-event overhead matching conventional stream processing.

Blackwell, D. (2026). Drainability: When Coarse-Grained Memory Reclamation Produces Bounded Retention. Technical Report.
doi:10.5281/zenodo.18653776

Defines drainability as a structural property of memory allocators and proves the O(1) vs Ω(t) dichotomy: allocators with the drainability property achieve bounded retention (O(1) granules retained), while those without it suffer unbounded growth (Ω(t) granules retained over time t). Establishes theoretical foundations for epoch-based, arena, and slab allocators.

Open Source & Services

View my complete open source portfolio and consulting services on their dedicated pages.

Contact: