Your app is slow. Here's where.

A Java monolith with slow responses, memory leaks under sustained traffic, and concurrency bugs that only appeared in production. Thin coverage and an unreliable pipeline made every release a risk.

• Refactored into microservices incrementally, guided by profiling rather than guesswork
• Found and fixed memory leaks with the YourKit profiler
• Handled race conditions and optimised for thread safety
• Led integration testing across the new boundaries
• Implemented obfuscation compatible with Java 21

5G network automation generates high-volume operational data across systems never designed to talk to each other — internal platforms, vendor tooling and telecom inventory, each with its own transport and format.

• Java microservices on Spring Boot and Maven, split for independent deployment
• Integration adapters over SFTP, WinSCP, REST and UIV for cross-platform exchange
• Hibernate/JPA persistence over MySQL, restructured to speed up data handling
• Real-time processing paths sized for live 5G network volume

Production infrastructure for a telecom operator at national scale, under real vendor scrutiny. The work is unglamorous: making systems that don't want to talk to each other exchange data reliably, without a person in the loop.

• Large enterprise environments with external stakeholders
• Integration across protocols, not just HTTP
• Distributed service design under high data volume

A parsing engine used by HR platforms to turn resumes and job descriptions into structured data. Accuracy varied by format, production issues surfaced only via customer tickets, and thread contention was quietly capping throughput.

• Refined parsing algorithms across diverse document formats
• Built an Early Warning System so anomalies were caught before customers noticed
• Profiled with YourKit to locate thread contention, then optimised those paths
• Diagnosed memory problems from heap dumps and applied targeted fixes
• Researched and implemented Java FIPS for cryptographic compliance
• Refactored core modules to cut cyclomatic and cognitive complexity

This is the engagement that shaped how I work: most of the value came from measurement — profiler, heap dump, monitoring — not from writing new features.

A Java thread dump tells you what every thread is doing, but not what's wrong — the answer is in the edges between threads. The hosted analysers all want you to upload the dump, which contains your internal class names, hostnames and business logic.

• Detects deadlocks by finding cycles in the lock graph
• Ranks contended monitors by how many threads are queued behind them
• Surfaces the hottest stack frames across runnable threads
• Parses entirely in the browser — nothing leaves the page

• React with hooks; analysis memoised so a large dump isn't reparsed per keystroke
• Parsing and graph logic kept pure and free of React, so it unit tests directly
• Iterative cycle detection, not recursive — the pathological dumps this exists to read are exactly the ones that would blow a call stack

A thread parked on a condition or inside Object.wait() has already released its monitor. Treating those as blocking edges is the standard way to report deadlocks that don't exist — so only true monitor entry creates an edge, and a regression test holds that line.

A booking platform is really two applications sharing a database. Customers search destinations and buy tickets; operators create flights, set schedules and change pricing. Blur the boundary and you get a customer who can reprice a flight.

• Customer flow for destination search, seat selection and purchase
• Admin modules for flight creation, scheduling and pricing
• Role-based access enforcing a hard separation between the two
• The services behind both surfaces, and the data model they share

The clearest example of end-to-end ownership: one person responsible from the interface a customer touches down to the access rules in the database. That's the shape most of my freelance work takes.