§ 01Snapshot
- Levelmid-level engineer, about four years of professional experience, including two stints leading small teams. Best matched to mid-level PR reviews.
- Roles heldfull-stack developer (.NET microservices + React) · senior real-time 3D (Unreal Engine) developer · team lead of four developers, twice · freelance gameplay programmer
- Scaleled teams of four · stabilised a saga worker under a burst of a few hundred concurrent processing jobs · cut frame-rate loss in a desktop 3D product by more than 90%
- Industriesproperty tech (interactive 3D property showcases) · CAD / furniture visualisation · interactive 3D configurators · games
- Company typessmall product companies and studios · remote startup teams
- Specialtiesrace conditions and transaction isolation in PostgreSQL · saga orchestration and the outbox pattern · service boundaries, CQRS and DDD · real-time and C++ performance (GC pressure, pooling, event-driven UI) · resilient LLM pipelines (checkpointing, provider failover) · reviewing LLM-written code for non-obvious bugs
- Best forseed startup · scale-up teams with junior and mid-level developers · game and 3D studios
- Core stackC# / ASP.NET Core / EF Core, C++20/23, Go (net/http), Python / FastAPI, TypeScript / React, PostgreSQL, Kafka, S3, JWT / OIDC · Docker, Kubernetes, Helm, GitLab CI, ArgoCD · OpenTelemetry, Prometheus, Testcontainers, NUnit · Unreal Engine 5, DirectX 11, HLSL · AI-assisted development with coding agents
- Time zonesAmericas time zones
§ 02Services
| ✓ | PR/MR code review | mid-level; .NET, Go, C++, Unreal, React |
| ✓ | Architecture review | service-level: transactions, sagas, boundaries |
| — | Architecture design | Not offered by this expert |
| — | Audit / due diligence | Not offered by this expert |
| ✓ | Vibe-code rescue | focused on concurrency and correctness bugs in AI-written code |
| ✓ | Team mentoring | junior and mid-level developers |
§ 03Track record
Fixing a stale-snapshot race with one RepeatableRead transaction
Concurrent producers stamped read-model snapshot versions independently of when they read the content, so an older read could win the last-writer-wins check and freeze stale data.
One of our experts bound version allocation to the content by running sequence allocation and the whole slice build inside a single PostgreSQL RepeatableRead transaction.
Correctness restored under multi-producer load, with the change contained to one dispatcher class.
A saga worker stuck in an endless compensation loop
Failed background tasks in a saga worker entered an endless compensation loop that starved the outbox queue and silently lost data.
One of our experts added a state guard so compensating steps were excluded from the standard timeouts, re-anchored deadlines to the actual step start instead of queue entry, and added queue-age monitors with Prometheus and OpenTelemetry.
The deadlock was gone, and the worker held full throughput under a burst of a few hundred concurrent file-processing sagas.
Splitting an overloaded service into admin and public APIs
A single microservice served both internal editing and public reads, and did neither well.
One of our experts split it into an internal admin API with normalised tables for data integrity and a public API with denormalised tables, collapsed into a handful of endpoints, applying CQRS and DDD.
Far fewer network round trips and front-end caching, so reads got much faster.
Frame-accurate video scrubbing by serving frames, not a stream
Walkthrough videos scrubbed in the browser stuttered and mis-seeked when served as a single video file.
One of our experts integrated FFmpeg into the .NET pipeline to decode each upload into a few hundred sequential frames, stored and served individually.
Scroll-scrubbing became frame-accurate and stutter-free.
Turning a single-threaded render step into a scalable worker pool
Generating 3D panorama media relied on a single-threaded render capture step that couldn't keep up.
One of our experts built an end-to-end pipeline from the admin UI to a render service, and turned the capture step into a horizontally scalable pool where multiple engine instances claim tasks concurrently.
Rendering throughput now scales by adding workers.
Cutting frame-rate loss by more than 90% in a desktop 3D product
The Windows build lost most of its frame rate during normal UI use.
One of our experts refactored the UI onto a view pattern and replaced polling with event-driven logic.
Frame-rate loss dropped by more than 90%.
A native host so a 3D engine could use a .NET CAD library
The product needed a free CAD library that only existed for .NET, inside a C++ 3D engine.
One of our experts built a native host enabling .NET interop, implemented CAD-to-engine data conversion, and a synchroniser that kept engine structs in step with their C# counterparts.
The product could use the library without a commercial alternative.
Leading a team of four: guidelines, pipeline docs and code reviews
Small 3D teams worked without shared rules or a predictable task pipeline.
One of our experts led a team of four twice: assigned work by skill, ran biweekly progress and architecture discussions, did code reviews, introduced Scrum, and wrote the company guidelines and production-pipeline documentation.
Clearer communication between developers and managers and a documented way of working.
Garbage-collection pressure behind level-loading frame drops
Severe frame-rate drops happened whenever a level loaded.
One of our experts traced them to garbage-collection pressure, moved loading to asynchronous, and introduced object pooling to pre-create and reuse objects.
Much better sustained performance.
Adding two caching layers where there were none
Cloud-hosted 3D assets and generic data were fetched again and again, so loading was slow.
One of our experts added an in-memory cache for generic data and a file-based cache for byte-convertible assets such as dynamic meshes.
Load performance improved dramatically.
§ 04What you can book
Reviewing a card-authorization flow
A team builds or extends a card-authorization path (ISO 8583 messages, fraud rules, issuer calls). The reviewer has hands-on experience with this kind of flow and checks connection handling under concurrency, that card numbers never reach logs or plain columns, fraud thresholds that change without redeploys, and response codes that match the spec.
An annotated PR review with prioritized fixes.
Reviewing financial-message parsing
A service parses structured financial messages, and one malformed optional field takes down the whole message. The reviewer checks how the parser separates hard failures (a missing required field) from soft ones (an optional field that should degrade to inspectable raw bytes), and whether the hot path allocates more than it needs.
Review notes and test cases for the failure paths.
Making an LLM pipeline survive failures
A multi-stage LLM document pipeline loses work whenever a provider times out or rate-limits. The reviewer, who has built this kind of pipeline, checks for an explicit state machine, atomic checkpoints per stage, bounded concurrency that doesn't block the event loop, and failover that treats timeouts and rate limits differently.
A resilience review with a prioritized fix list.
Mid-level PR review focused on concurrency and transactions
Junior and mid-level developers ship backend code, much of it AI-assisted, and nobody has time to check the ordering and transaction assumptions.
Per-PR review of transaction boundaries and isolation levels, retries and timeouts, saga/outbox handling, and service boundaries, with comments written to teach rather than just fix.
Reviewed PRs and a running list of patterns each developer should watch for.
Unreal Engine / C++ performance review for a small 3D team
A small team's real-time 3D app stutters, loads slowly or drops frames, and nobody has had time to profile it.
Profile the hot paths, then look at polling vs events, garbage-collection pressure, asynchronous loading, pooling and caching.
A short findings report ranked by impact, with reviewed fixes for the top items.