Resume

Principal software engineer specializing in high-load distributed systems, backend architecture, and scalable system design, with 20+ years of experience.

Resume & Profiles

• 📄 Download Resume (PDF)
• 💼 LinkedIn

Core Expertise

• Distributed systems and high-load architectures
• Backend engineering (Java, Rust, cloud-native stacks)
• Event-driven systems and near-real-time message processing
• Data modeling and consistency trade-offs
• Performance optimization and system reliability

Engineering Approach

Software engineering, for me, is not about frameworks or languages.
It is about building systems that behave correctly under pressure.

Over the past 20+ years, my work has focused on high-load distributed systems, data-intensive platforms, and architectural design that holds under real-world constraints.

Most problems at scale are not about code. They are about:

• consistency
• concurrency
• failure handling
• and making trade-offs explicit

Distributed Systems & High-Load Architectures

Designing systems that process hundreds of millions of operations daily requires more than scaling horizontally. It requires understanding where the system breaks.

I focus on:

• contention reduction and transaction design
• eventual vs strong consistency trade-offs
• system decomposition by responsibility boundaries
• predictable behavior under peak load

Backend Engineering

Hands-on development is a core part of my work.

Technologies are tools, not identity, but I’ve spent most of my time working with:

• Java (Spring Boot, distributed systems)
• Rust (exploring zero-cost abstractions and compile-time design)
• Cloud-native stacks (Kubernetes, GKE, Azure)

The emphasis is always on:

• correctness
• performance
• simplicity under complexity

Architecture & System Design

Architecture is not diagrams. It is the ability to:

• identify system boundaries
• define clear responsibilities
• and evolve systems without breaking them

I work with:

• microservices and service decomposition
• Strangler pattern for legacy systems
• domain-driven design principles (pragmatic, not dogmatic)

Data, Storage & Messaging Systems

At scale, data is often the system, and the flow of data defines system behavior.

Experience includes:

• relational systems (PostgreSQL, Oracle)
• distributed storage (Cosmos DB, Cassandra)
• messaging and streaming platforms (Kafka, RabbitMQ)

Key focus areas:

• data modeling for performance
• designing event-driven systems
• near-real-time message processing
• consistency vs availability trade-offs
• cost optimization at scale

Performance & Reliability

Systems fail in edge cases, not in happy paths.

My approach:

• analyze real behavior through generated test scenarios
• identify bottlenecks via system-level thinking
• design for predictable degradation, not ideal conditions

Current Focus

Recently, I’ve been exploring:

• Zero-cost dependency injection in Rust
  → pushing architectural patterns into compile-time

• Bridging enterprise system design with low-level control
  → combining high-level architecture with performance guarantees

• Reducing accidental complexity in large systems
  → making systems understandable and maintainable

Publications

Some of these ideas are explored in more detail in my articles:

• Computer vision and camera calibration for autopilot systems
• Agile git branching strategies in real-world teams
• Dependency injection and architectural patterns in Rust

See full list → /publications/

Closing

I’m interested in problems where:

• scale matters
• correctness matters
• and simple solutions stop working

If that’s the kind of system you’re working on, we’ll likely speak the same language.