Michał KrzewicaBackend Developer & AI Engineer

I build reliable backend systems and AI solutions that are ready for production.

From APIs and event-driven services to LLM applications and agent workflows built with LangGraph.

5+ years building production systems · Backend · LLMs · AWS

How I work

Good engineering starts with understanding the problem. From there, I move through design, implementation, testing and deployment — with room to revisit earlier decisions whenever something needs improving.

The process is shown as a graph, much like the agent workflows I build. Explore each step to see how I approach it.

how-i-work.graph idle

step 01 · scope

Understand the problem

Before writing code, I make sure we're solving the right problem and know what a successful outcome looks like.

Define clear goals and decide how to measure success
Understand the data involved and identify privacy requirements
Choose the right approach: real-time, streaming, asynchronous or batch processing

success metricsconstraintstrade-offs

success   measurable on a golden set
latency   stream progress to the UI
cost      batch where real-time isn't needed
privacy   keep only what's needed

step 02 · design

Design the system

I start with the contracts, data model and system boundaries. A clear design makes the implementation easier to maintain and gives other teams a solid foundation to build on.

Define REST APIs and event schemas
Design data models around real access patterns
Keep the backend and LLM components clearly separated

RESTSSESQSMongoDB

POST /jobs               → 202 Accepted
GET  /jobs/{id}/stream   → text/event-stream
job.completed            → SQS

step 03a · backend

Build the backend

AI features still depend on well-designed backend systems. I focus on making those foundations reliable, scalable and easy to work with.

Build services and APIs with clear, consistent contracts
Move long-running tasks to queues and serverless workers
Deploy containerized services to ECS and make them observable

PythonFastAPIPHPSymfonySQSLambdaDocker

@router.post("/jobs", status_code=202)
async def create_job(cmd: CreateJob) -> JobAccepted:
    job = await jobs.create(cmd)
    await queue.publish(JobQueued(job.id))
    return JobAccepted(id=job.id)

step 03b · llm

Build the LLM layer

I build agent workflows as explicit graphs, so each step has a clear purpose and can be tested, retried and improved independently.

Use LangGraph for parallel execution, validation and retries
Keep integrations flexible with LangChain and support for multiple model providers
Manage and version prompts separately from application code

LangGraphLangChainmodel-agnosticRAG

builder.add_node("draft", draft_section)
builder.add_node("validate", validate)
builder.add_conditional_edges(
    "validate", route, {"retry": "draft", "ok": "merge"}
)

step 04 · verify

Test and evaluate

An AI feature isn't ready just because it works in a demo. I test the underlying services, evaluate model outputs and use regressions to guide improvements.

Test API contracts and backend behavior
Use golden datasets and LLM-as-judge evaluations to track output quality
Fix regressions by refining prompts and adjusting graph logic

golden setsLLM-as-judgeLangfuse

run    golden_set         → regression found
route  validate → draft   (retry)
run    golden_set         → passed
ship   ✓

step 05 · ship

Ship with confidence

I aim for deployments that are predictable, security measures that make sense, and infrastructure that doesn't cost more than it needs to.

Add safeguards against prompt injection and inappropriate outputs
Use batch APIs when immediate responses aren't necessary, reducing API costs by around 50% in the right workloads
Deploy services with Docker and ECS, using Lambda for event-driven tasks

guardrailsBatch APIsDockerECSCloudFront

guardrails   prompt_injection ✓   moderation ✓
mode         batch   (≈ ½ the cost of real-time)
deploy       docker → ecs

step 06 · observe

Monitor and improve

Once a system is live, I want to know what it's doing, where it struggles and how it can be improved.

Log the model, token usage and prompt version for each AI call
Trace LLM workflows with Langfuse and OpenTelemetry
Use what the traces and evaluations reveal to guide the next iteration

LangfuseOpenTelemetryLLM-as-judge

trace   model · tokens · prompt_version
eval    LLM-as-judge evaluators
↺       back to scope

› press Play to run the graph

About

Backend first. AI where it adds value.

I'm a backend developer with over five years of production experience, working across APIs, data modeling, event-driven systems and cloud infrastructure.

Since 2025, I've also been focused on AI engineering — building agent workflows, model-independent LLM pipelines, evaluation systems and observability for applications that need to work beyond a demo.

I care about systems that are easy to understand, measurable in production, mindful of privacy and straightforward for other developers to extend.

backend

Backend & APIs

Services, APIs and data models designed around clear contracts and real application needs. Streaming where it makes sense, without unnecessary complexity.

cloud

Cloud & delivery

AWS infrastructure built with the right tools for the job: Lambda and SQS for asynchronous workloads, Docker and ECS for services, and CloudFront for content delivery.

backend

Event-driven & async

Long-running and resource-intensive tasks handled outside the main request cycle, using queues, serverless workers and batch processing.

LLM systems & agents

Structured agent workflows, flexible LLM integrations and RAG pipelines designed for real applications rather than one-off demos.

Evaluation & observability

Practical ways to track quality and diagnose issues, from golden datasets and LLM-as-judge evaluations to traces for individual AI calls.

Privacy & guardrails

Input validation, prompt-injection defenses and moderation, with a focus on collecting and retaining only the data the system actually needs.

Selected projects

A closer look at the systems I've worked on.

Backend architecture, event-driven processing and LLM applications — with an emphasis on how they work under the hood.

01 · Agentic workflows

Multi-agent workflows with LangGraph

An LLM-powered service that generates large, structured documents by processing multiple tasks in parallel and streaming progress to the browser as the work happens.

Nested LangGraph workflows with parallel execution, validation and retries at each step, plus MongoDB checkpointing to support recovery.
Model-independent integrations through LangChain, prompts managed outside the application code, and safeguards against prompt injection and inappropriate outputs.
Golden-dataset evaluations to catch quality regressions and guide improvements to prompts and workflow logic.

PythonFastAPILangGraphLangChainSSEMongoDBLangfuse

GET /documents/stream text/event-stream

event: node_started data: {"node":"plan"}

event: fan_out data: {"branches":3}

event: node_done data: {"node":"section_1"}

event: validation_failed data: {"node":"section_2","retry":1}

event: node_done data: {"node":"section_3"}

event: node_done data: {"node":"section_2"}

event: complete data: {"checkpoint":"saved"}

02 · Event-driven backend

Batch processing for text and audio

An event-driven pipeline for processing long documents and audio with LLMs, designed to handle longer workloads without keeping users waiting for synchronous responses.

Provider batch APIs instead of real-time calls, cutting API costs by around 50% for suitable workloads.
Audio processing with chunked browser recordings, ffmpeg-based merging and speech-to-text with speaker diarization. Audio files aren't retained.
Logging for every AI call, including model, token usage and prompt version, with Langfuse tracing over OpenTelemetry and LLM-as-judge evaluations.

AWS LambdaSQSPHPLangfuse

Audio processing pipeline

1Browser — audio recorded in chunks
2ffmpeg — chunks merged into a single recording
3Speech-to-text — transcription with speaker diarization
4Batch LLM processing — jobs handled through SQS and Lambda
5Result & observability — output traced, audio discarded

Cost per job

Real-time API 1×

Batch API ≈ 0.5×

Stack

The tools behind the systems

I choose technologies based on what the system needs, rather than trying to fit every problem into the same stack.

Explore each layer to see which tools I use and how they fit together in practice.

01Edge

BrowserSSE client
CloudFrontCDN

02API

Python / FastAPI
PHP 8 / Symfony
RESTcontracts
SSElive progress

03Async

SQSqueues
AWS Lambdaworkers
ECS · Dockerservices

04LLM

LangGraphagents
LangChain
Any LLM providermodel-agnostic
Batch APIs≈ ½ cost
RAG
Guardrailsinjection · moderation

05Data & quality

MongoDBdata · checkpoints
S3files
Langfusetraces
OpenTelemetry
Evalsgolden sets

Whole stack · 19 tools

Backend services at the core, an LLM layer where it adds value, and asynchronous processing for work that doesn't need to happen in the request cycle. AI calls are traced so behavior and performance can be investigated.

Contact

Have something interesting to build?

Whether you're working on a backend that needs to scale, bringing an LLM feature into production or connecting the two, I'd be happy to talk.

E-mail me LinkedIn

michalkrzewica@wp.pl +48 667 502 266