Senior Backend Engineer | Architect

I transform legacy systems into scalable architectures.

Focused on system ownership, observability, and performance under real-world load.

I take responsibility for complex systems, make them understandable, and evolve them into reliable, scalable architectures.

ex-tonies Legacy Modernization High-Load Systems
Get in touch View case studies

What I do

I work on systems that are already central to the business and hard to change.

System modernization

I work on legacy environments where architecture, performance, and delivery quality have become limiting factors.

  • Turn opaque systems into observable, measurable platforms
  • Reduce technical drag through structural modernization
  • Define boundaries, ownership, and direction under real constraints

Technical ownership

I focus on system-level clarity instead of isolated features.

  • Identify and eliminate performance bottlenecks
  • Align architecture with business-critical requirements
  • Drive decisions through evidence, not guesswork

Case studies

Selected examples of how I work: clarify the system, expose the real problem, then improve the architecture with measurable effect.

Legacy ERP

Observability & performance

Inherited a legacy ERP system with little visibility into runtime behavior and no reliable basis for performance analysis.

  • Introduced application-level observability across user activity, errors, database operations, and endpoint behavior
  • Created a basis for data-driven debugging and prioritization
  • Identified critical bottlenecks in request handling and database usage
Result: targeted optimizations with up to ~99.9% performance improvement in critical queries.
High-traffic e-commerce

High-load backend platform

Worked on a backend platform required to remain stable under extreme seasonal load and growing system complexity.

  • Co-shaped a high-traffic API platform under real production load
  • Replaced tightly coupled structures with modular, domain-oriented design
  • Built internal APIs and reduced dependency on external systems
Result: stable operation under 4–10x peak load.
Legacy analysis

Zend 1 modernization strategy

Analyzed a heavily coupled Zend 1 monolith with circular dependencies, static loading patterns, and runtime initialization complexity.

  • Mapped architectural pain points hidden behind feature requests
  • Clarified why apparently small changes required structural work first
  • Used system analysis to turn vague feature work into realistic technical decisions
  • Used system analysis to turn vague feature work into a predictable modernization roadmap.

How I work

My approach is simple: make the system visible, define what actually matters, then improve it in ways that hold under real usage.

VISIBLE Make problems measurable before solving them.
STRUCTURAL Prefer systemic improvements over cosmetic fixes.
OWNED Take responsibility instead of waiting for perfect requirements.
SCALABLE Design for maintainability, load, and future change.

Focus areas

This is where I create the most leverage.

Architecture & modernization

  • Legacy modernization
  • Backend architecture (PHP, Symfony, APIs)
  • Modularization and boundary definition
  • System evolution under business constraints

Performance & reliability

  • Observability and bottleneck analysis
  • High-load backend systems
  • Data-driven debugging
  • Operational stability under real traffic