Marcin Borecki
Training & workshops
Hands-on workshops on async .NET, performance, SQL Server and PostgreSQL, Azure architecture and production AI, built around your own code.
Workshops for engineering teams that want to get better at the hard parts: concurrency, performance, data, cloud architecture and AI systems in production. Every workshop is built around your code, your incidents and your decisions, not a generic slide deck.
Hands on keyboards
Short explanations, then exercises on realistic code: reproduce the failure, observe it, fix it, prove the fix.
Your system on the whiteboard
We map one real flow end to end and stress it: failure modes, ownership, identity, data and recovery.
A choice the team must make
Options, evidence and trade-offs laid out so the team leaves with a decision and a record of why.
Workshop catalogue
Each topic can run as a coding lab, an architecture session or a combination. Length, depth and group size are agreed with you. The linked articles show the style and level of the material.
Async .NET that survives production
Tasks, cancellation and timeouts as separate outcomes; owning work that outlives its caller; deadlines across stages; diagnosing thread pool and dependency queueing.
- WaitAsync, WhenAny and the cancellation contract
- Ownership, idempotency keys and lost acknowledgements
- Reading async stacks and runtime events
Preview: Timeouts and cancellation · Diagnosing .NET queueing
.NET memory and performance diagnostics
From symptom to cause with real tools: allocation versus retention, pooling, ValueTask, zero-copy parsing and measurements that compare like with like.
- dotnet-counters, dotnet-trace and dump analysis
- ArrayPool, MemoryPool and buffer ownership
- Benchmark design that answers the actual question
Preview: Allocation or retention · Pooling across await
SQL Server and PostgreSQL for application teams
What the database actually does with your queries: plans, memory grants and spills, rows read versus rows returned, JSON indexing, batching and maintenance you can verify.
- Reading execution plans without guesswork
- EF Core batching and resumable exports
- Statistics, indexes and their write costs
Preview: Memory grants and spills · Counting the rows read
Reliable AI agents in .NET and Azure
Agents as distributed systems: tool authority, idempotent side effects, human approval that still means something after a restart, cost per successful task.
- Tools as APIs with a different caller
- Durable replay and external effects
- Budgets, approvals and audit trails
Preview: Agent tools as APIs · After the restart
RAG and LLM evaluation you can trust
Retrieval as a contract, quality as a distribution, executable oracles for numbers and negation, and the decision between local and hosted models.
- Retrieval contracts and eligibility
- Evaluation sets that fail plausible wrong answers
- Decision APIs: probabilities, thresholds, error cost
Preview: RAG in .NET · Decision APIs series
Azure architecture and recovery
Identities, event-driven processing, deployment that verifies more than startup, and recovery runbooks rehearsed before the incident.
- Managed identities and token caching
- Service Bus delivery, ordering and duplicates
- Backup, restore and proving the application works
Preview: Three Azure identities · A recovery drill
AI-assisted engineering without losing ownership
How teams review AI-written code, keep architecture shared, and make sure junior developers still learn the craft.
- Review practices for generated changes
- Counterexamples and test-first disagreement
- Measuring review queues honestly
Preview: Who owns AI-written code · The junior developer
Technical due diligence for AI products
For founders, CTOs and investors: what to ask, what to inspect, and how to tell an operable system from a convincing demo.
- Following a claim past the tool reply
- Readiness as a set of evidence gaps
- What survives when models become a commodity
Preview: Technical due diligence · Buying an AI product
How a workshop is prepared
The preparation is what makes it useful on Monday morning.
Conversation
We discuss the team, the systems and the questions that keep coming back in reviews or incidents.
Tailored agenda
I adapt the material and exercises to your stack and, where possible, to sanitised examples from your own code.
Hands-on sessions
Short explanations, long exercises, discussion of real trade-offs. Participants work, not just watch.
Follow-up
Written notes, the worked examples and a list of agreed next steps for the team.
Practical questions
Who are the workshops for?
Mostly developers, senior engineers, architects and tech leads. The due diligence and AI adoption topics also work for CTOs, founders and investors.
Can you combine topics?
Yes. Common combinations are async plus performance diagnostics, or agents plus RAG evaluation. We pick what serves the team's current problems.
What do participants need?
For coding labs: a laptop with the agreed SDKs and tools installed; I send the setup list in advance. Architecture sessions need a whiteboard and the people who know the system.
Do you also run sessions for conferences or communities?
Write with the details of the event and the audience, and we can see what fits.
Plan a workshop for your team
Tell me about the team, the stack and the questions you want answered. I will propose an agenda.