Pony developer — concurrent, memory-safe actor systems

I am a Pony-language developer, and I write highly concurrent, memory-safe systems that stay predictable under heavy load. Unlike the Erlang, Go, or Rust work you may have seen, my whole practice is built around Pony specifically: the actor model gives me thousands of tiny isolated actors that never share mutable state, so I never fight locks, race conditions, or data corruption. Messages flow between actors, the runtime schedules them across every core, and the result is a backend that scales up cleanly instead of collapsing into deadlocks the moment traffic spikes.

What makes Pony different is its capabilities-secure type system. Reference capabilities let the compiler prove, before your service ever runs, that two actors can never touch the same mutable data at the same time. That means data-race freedom is guaranteed at compile time, not hoped for in production. I lean on this hard: I design the actor boundaries, choose the right reference capabilities for each message, and keep allocation patterns friendly to the per-actor garbage collector so latency stays low and consistent. No stop-the-world pauses, no surprise contention.

I take on greenfield low-latency services, message-heavy pipelines, and performance-critical components where a millisecond matters. I can also profile and rescue an existing Pony codebase, tighten its actor topology, and add tests and benchmarks so you can trust the numbers. If you need throughput that holds under real concurrency, I deliver it.

— Pony application and library development from scratch
— Actor-model design: message protocols, actor topology, backpressure
— Capabilities-secure typing and data-race-free architecture
— Low-latency, high-throughput backend and pipeline services
— Per-actor GC tuning and latency profiling
— Benchmarks, load testing, and performance hardening