Your NameBackend Software EngineerContact
Available for remote opportunities

Systems · APIs · Data

Backend systems that stay reliable under pressure.

I design and build dependable APIs, asynchronous workflows, and data-intensive services with clear operational boundaries.

Contact me View projects

Architecture / 01

system.topologyhealthy
API gatewayingress
Job serviceorchestrate
Event streamdecouple
PostgreSQLpersist
tracesp95 measuredretries bounded
YN

Backend Software EngineerRemote · UTC+3

01Backend architecture02REST & event-driven APIs03PostgreSQL & data modeling04Cloud infrastructure05Performance optimization

About

Engineering clarity into complex systems.

Backend work is strongest when the architecture is understandable, the failures are expected, and the path to change stays open.

I am a backend engineer focused on the systems behind demanding products — the APIs, data flows, and operational tooling that need to remain understandable as they grow.

My work balances delivery with long-term reliability. I turn ambiguous product requirements into simple service boundaries, measurable performance, and maintainable code.

Experience

Systems delivered. Lessons retained.

Demonstration entries show the intended structure. Replace them with your real experience in the content folder.

SampleRemote

Backend Software Engineer

Product Systems Studio

Sample experience entry demonstrating how production-focused backend work is presented.

  • Designed service boundaries and API contracts for asynchronous product workflows.
  • Introduced consistent tracing and structured error handling across backend services.
  • Improved deployment safety through automated checks and backward-compatible migrations.
TypeScriptPostgreSQLRedisDockerOpenTelemetry

SampleHybrid

Backend Developer

Digital Operations Lab

Sample experience entry focused on data access, integrations, and maintainability.

  • Reworked expensive database access around measured query patterns and clear indexes.
  • Built integration workflows with idempotent processing and explicit retry policies.
  • Documented operational decisions and practical runbooks for recurring incidents.
PythonFastAPIPostgreSQLRabbitMQ

Selected projects

Architecture explained through decisions.

Case studies focus on the constraint, the technical choice, and the trade-off—not a list of technologies.

01

Distributed systems

Sample

Sample case study

Distributed Job Processing Platform

A resilient backend platform for long-running workloads, built around explicit job state and predictable recovery.

Problem
Synchronous processing tied expensive workloads to request lifecycles and made partial failures hard to recover.
Decision
Separated admission, execution, and result delivery with durable job state, idempotent workers, and controlled retries.
TypeScriptPostgreSQLRedisDocker
Read case study
System flow
APIQueueWorkersResults
02

Data platform

Sample

Sample case study

Internal Analytics API

A query-focused service that gives product teams consistent access to operational data without exposing storage details.

Problem
Teams were duplicating reporting queries and coupling internal tools directly to a changing relational schema.
Decision
Introduced a stable read API, pre-aggregated views, and explicit freshness guarantees for expensive datasets.
PythonFastAPIPostgreSQLOpenTelemetry
Read case study
System flow
SourcesModelsAPIClients
03

Event-driven architecture

Sample

Sample case study

Event-Driven Notification Service

A delivery service that turns domain events into reliable, policy-aware notifications across multiple channels.

Problem
Product services owned their own email logic, producing inconsistent retry behavior and tightly coupled templates.
Decision
Centralized delivery behind events while preserving channel isolation, auditability, and per-recipient preferences.
TypeScriptKafkaPostgreSQLKubernetes
Read case study
System flow
EventsPolicyChannelsAudit

Technology

Tools chosen for the system in front of me.

Grouped by the work they enable. No arbitrary percentages, just practical production context.

01

Languages

  • TypeScriptprimary
  • Pythonproduction
  • SQLprimary
02

Backend

  • Node.jsproduction
  • FastAPIproduction
  • RESTprimary
  • Async workflowsprimary
03

Data & messaging

  • PostgreSQLprimary
  • Redisproduction
  • Kafkaworking
  • RabbitMQworking
04

Infrastructure

  • Dockerproduction
  • Kubernetesworking
  • AWSworking
  • Terraformworking
05

Quality & operations

  • Pytestproduction
  • Vitestworking
  • OpenTelemetryworking
  • Grafanaworking

Engineering approach

Reliable software begins before the first incident.

01

Design for failure

Timeouts, retries, idempotency, and observability are part of the design—not cleanup work after launch.

02

Measure before optimizing

Start with traces and real workload data, then improve the bottleneck that users can actually feel.

03

Prefer simple systems

Choose the least complex architecture that meets today’s constraints and leaves a clean path to evolve.

04

Make decisions visible

Document important trade-offs so the next engineer understands why the system looks the way it does.

Start a conversation

Building something that needs a reliable backend?

I am open to remote backend engineering opportunities and selected contract projects.

Send an email