Skip to content

Distributed Systems Engineer

Dan Blajinschi

I design microservice backends and ship them all the way to production — gRPC, Kafka, and a CI/CD pipeline I built and run myself.

Open to relocationEU work authorization · registered PFA (can invoice for contract work)
Download CVGitHubLinkedInTelegramLive site
DB

I'm a Distributed Systems Engineer. I design microservice backends (gRPC, Kafka/RabbitMQ, PostgreSQL/MongoDB/Redis), build the frontends on top, and own the complete delivery path — CI/CD, containers, ingress, and observability — end to end. I also build AI agent systems as a first-class discipline: my own tool-calling harness, multi-step agent loops, and knowledge-graph retrieval, tuned for cost and efficiency.

What I do

Capabilities

Distributed Systems Engineering

core

Designs and builds production microservice systems that stay correct and fast under load — service decomposition, gRPC, event-driven messaging (Kafka, RabbitMQ), and data-consistency guarantees.

  • LocknBook — a complex ASP.NET Core 8 microservices backend over gRPC + Kafka + PostgreSQL
  • OPSWAT Cloud Email Security — production .NET + NestJS services over gRPC + Kafka

CI/CD & Delivery

core

Stands up a complete delivery pipeline and the infrastructure to run it — build/test/deploy automation, public ingress, containers, and observability — solo.

  • LocknBook — GitLab CI/CD on a self-hosted Raspberry Pi ARM64 runner, Cloudflare Tunnel ingress, Docker Compose, Prometheus/Grafana/Loki
  • Continental Automotive — production CI/CD pipelines (Jenkins) on Linux

Backend Engineering & Performance

core

Builds high-throughput backend services and optimizes where it counts — data modeling, indexing, caching, and measurable speedups.

  • OPSWAT — custom MongoDB tokenization for instant search on the largest collection
  • IMDB Search Optimization — sub-1-second query tuning across MySQL/PostgreSQL

AI Engineering & Agent Systems

working

Designs and optimizes LLM agent systems end to end — tool-calling harnesses, multi-step agent loops, and knowledge-graph retrieval — tuned for reliability, cost, and efficiency. AI as a discipline, not just an API call.

  • Built my own agent harness (tool-calling runtime, sandboxed execution, persistent sessions) — being extended into a fuller agent framework
  • OPSWAT — optimized AI agent workflows with agent loops and knowledge-graph retrieval, cutting token cost and increasing efficiency
  • Daily AI-driven development with Claude Code, Cursor, and MCP

Hands-on Full-Stack & Frontend

working

Ships whole features across the stack, including building real frontends — comfortable owning the UI layer, not a frontend specialist.

  • LocknBook — built the Next.js 16 / React 19 / Tailwind v4 guest frontend
  • LioBlajaPad — full-stack real-time collaborative web app

Systems & Low-Level Engineering

working

Comfortable below the framework line — concurrency, OS primitives, networking, and Linux internals that underpin the distributed-systems work.

  • Network Monitor — multithreaded C/ncurses tool parsing /proc/net
  • Dense Matrix Multiplication — serial + OpenMP performance benchmarking

The road so far

Experience

  1. 07/2023 – PresentCurrent
    OPSWAT Technologies logo

    Middle Software Engineer

    OPSWAT Technologies

    Backend engineering on the Cloud Email Security product — scalable microservices in .NET and Node.js, performance optimization, and operational visibility.

    • Designed scalable microservices-based backend systems in .NET and Node.js
    • Custom MongoDB tokenization strategy for instant search over the largest collection
    • Secure Microsoft 365 Graph API integration for automated tenant onboarding and mail flow
    • Real-time statistics engine on InfluxDB + gRPC for threat and email-traffic visibility
    • Test coverage to pass a security audit for a Global Availability release (Jest + xUnit)
  2. 12/2022 – 07/2023
    Continental Automotive Romania logo

    Software Developer

    Continental Automotive Romania

    Backend services development, testing, and CI pipelines in a Java/Spring-style production environment.

    • Built backend processing tools using Java, Maven, and JUnit
    • Built data-aggregation pipelines and report-generation systems from configurable inputs
    • Worked with CI/CD pipelines (Jenkins) and Git in a Linux-based environment
  3. 2021 – 2024
    ImpactAcademies, Little Developers Academy, Girls Go IT logoImpactAcademies, Little Developers Academy, Girls Go IT logo

    IT Teacher (part-time)

    ImpactAcademies, Little Developers Academy, Girls Go IT

    Taught programming to youth — React, C#, Java, Python data science, databases — turning technology consumers into creators.

    • Taught frontend (React), C#, Java, and Python data science across age groups
    • Explaining technical concepts to non-technical audiences

Selected work

Projects

LocknBook

A deployed, sole-authored multi-tenant venue-booking platform — a complex .NET microservices backend over gRPC + Kafka, with a CI/CD pipeline running on a Raspberry Pi in my own home lab.

Distributed SystemsCI/CDFull-Stack

System architecture: REST at the gateway, gRPC between services, Kafka for async events.

Problem

Let venue owners publish tables and availability, and let guests discover venues and book a table in real time without a password account — while guaranteeing no two guests ever book the same table/slot.

Role

Sole author. Designed and built the entire system end to end: architecture, data model, booking algorithm, authentication, frontend, CI/CD, infrastructure, and observability. Bachelor diploma project (UPT).

Solution

Decomposed into focused ASP.NET Core 8 services (API gateway, booking, discovery, identity/OTP, tenant management, notification, and a cron worker), REST only at the gateway, gRPC between services, Kafka for async events. Made double-booking structurally impossible with a composite-primary-key reservation row and a hold-then-confirm life-cycle. Passwordless guest login via email OTP; JWT + claims for admins. Then took it all the way to production myself.

  • Atomic anti-double-booking via a (table_id, slot_start) composite PK + hold→confirm→expire life-cycle
  • gRPC + Kafka topology (otp-requested, booking-confirmed) with a KRaft-mode broker
  • Self-hosted GitLab CI/CD on a Raspberry Pi ARM64 runner, Cloudflare Tunnel ingress, Docker, Prometheus/Grafana/Loki

One person designing a distributed system and operating the pipeline that ships it — the end-to-end ownership the positioning claims, proven rather than asserted.

.NET 8ASP.NET CoregRPCApache KafkaPostgreSQLNext.jsReactTailwindDockerGitLab CI/CDCloudflare TunnelGrafana

OPSWAT — Cloud Email Security (Backend)

Business-proprietary

Production backend engineering on a commercial email-security product — performance at scale, Microsoft 365 integration, and security-audited release quality.

Distributed SystemsPerformanceAIProduction

IllustrativeKnowledge-graph retrieval — the kind of structure agents navigate for cheaper, sharper context.

Problem

Process large volumes of email for threat detection with instant search over the biggest data collection, secure tenant onboarding, and real-time operational visibility.

Role

Middle Software Engineer on the team (07/2023–present). Contributor — described strictly at the level of my own stated contributions; non-confidential.

Solution

Built and optimized backend services in a polyglot microservice system (.NET + NestJS over gRPC + Kafka, MongoDB + InfluxDB). Designed a custom MongoDB tokenization strategy so search over the largest collection stays instant; implemented secure Microsoft 365 Graph API integration for automated tenant onboarding and mail-flow configuration; built a real-time statistics engine on InfluxDB + gRPC; and covered the project with tests to pass a security audit for a Global Availability release. Also optimized AI agent workflows — introducing agent loops and knowledge-graph retrieval — which cut token cost and meaningfully increased efficiency.

  • MongoDB tokenization enabling instant search on a massive collection
  • Microsoft 365 Graph API tenant onboarding + mail-flow automation
  • Real-time statistics engine (InfluxDB + gRPC)

Real production experience on a security product at scale — backend performance and applied AI agent optimization that personal projects alone can't prove.

C# / .NETNestJSgRPCApache KafkaMongoDBInfluxDBMicrosoft 365 Graph APIAI agentsknowledge graphsDockerxUnitJest

Agent Harness

Private repo

My own LLM agent harness — a tool-calling runtime with sandboxed execution and persistent sessions — the foundation of a larger agent framework I'm building.

AIAgentsArchitecture

Problem

Give a language model reliable, safe access to real tools and durable context — the substrate every useful agent needs, built from first principles instead of a black-box SDK.

Role

Sole author. Personal framework, actively being extended.

Solution

Built an agent loop on the OpenAI Responses API: a tool-calling registry with strict JSON-schema validation, sandboxed tool execution (project-scoped), streaming event handling, and JSON-backed session persistence. Architected to grow into a fuller framework — more tools, multi-step loops, and knowledge-graph retrieval.

  • Tool-calling registry with strict parameter validation
  • Sandboxed tool execution (project-scoped only)
  • Persistent multi-turn sessions + streaming

Shows I build agent infrastructure from the ground up — the architecture behind the AI pillar, not just an API wrapper.

PythonOpenAI APItool callingagent loops

LioBlajaPad

Private repo

A real-time collaborative text-and-file workspace — full-stack, event-driven, built and shipped solo.

Full-StackReal-Time

Real-time shared text + file workspace (Socket.io).

Problem

Let a small group share text and files that stay in sync instantly across clients, with no refresh and safe concurrent edits.

Role

Sole author. Personal project.

Solution

Express + Socket.io backend pushing live updates over WebSockets, async-mutex to keep concurrent text/file operations race-free, Multer for uploads, and a responsive vanilla-JS dark-theme client; connection-limited to keep the shared session coherent.

  • WebSocket text + file synchronization across clients
  • Mutex-guarded concurrent operations (no race conditions)
  • Responsive, dependency-light frontend

The most openable proof — a visitor can grasp and run it immediately — and it shows real-time/full-stack delivery beyond the backend.

Node.jsExpressSocket.ioasync-mutexMulterJavaScriptHTML5CSS3

Systems & Low-Level Engineering

Private repo

A foundation in the layer beneath the frameworks — concurrency, networking, OS primitives, and measurable performance work in C.

SystemsPerformanceConcurrency

Problem

Build the systems-level fundamentals that distributed systems and performance work rest on.

Role

Sole author across a set of university and personal C projects, presented as one foundation entry rather than a list of exercises.

Solution

A real-time Linux network monitor (C/ncurses, multithreaded, parsing /proc/net); high-performance matrix multiplication (all six loop orderings, serial + OpenMP, blocked tiling, benchmarked on 1000–3000 N×N matrices); a sub-1-second IMDB search study (indexing + query tuning across MySQL/PostgreSQL, plus transaction-isolation experiments); a server-cluster job dispatcher; and lower-level work on sockets, threads, mutexes, and IPC.

  • Performance engineering with measurable results (sub-1s search; OpenMP speedup analysis)
  • Multithreaded systems programming against Linux internals (/proc, sockets, signals)
  • Concurrency primitives and orchestration (custom barrier, dispatcher/worker model)

Shows the distributed-systems and performance claims are grounded in genuine CS depth, not just framework familiarity.

COpenMPpthreadssocketsncursesLinuxMySQLPostgreSQLDocker

Tools of the trade

Stack

Languages

C#JavaCTypeScriptJavaScriptPythonSQLBash

Frameworks

.NET 8 / ASP.NET CoreNestJSNode.js / ExpressNext.jsReactSocket.io

Tools

gRPC + ProtobufApache KafkaRabbitMQPostgreSQLMongoDBRedisInfluxDBOpenAI APIAgent harness / tool-callingKnowledge graphsClaude Code / Cursor / MCPxUnitJest

Infrastructure

Docker & Docker ComposeGitLab CI/CDJenkinsCloudflare TunnelLinuxPrometheusGrafanaLokiCoralogix

Background

Education & languages

Bachelor of Engineering — Computer and Information Technology (CTI)

2022 – 2026

Polytechnic University of Timisoara

Languages

Romanian — nativeEnglish — C1 (IELTS)Russian — C2

Get in touch

Let's talk

Open to roles where I can own backend and distributed systems end to end. Open to relocation · EU work authorization · registered PFA (open to contract work).

dan.blajinschi8@gmail.comDownload CV
GitHub LinkedIn Telegram locknbook.com