2-day practical workshop · for teams and companies · on-site or remote

Make architectural decisions your team won't have to defend all over again in six months.

A practical workshop for engineering teams, tech leads, and engineering managers where:

  • technical trade-off decisions happen regularly,
  • legacy and modern systems have to be balanced,
  • and decisions need to stay defensible six months later.

Sound familiar on your team?

  • Meetings end without a real decision, only more questions — and next week everyone runs into the same wall again.
  • It's hard to explain why you chose a direction — and two weeks later nobody remembers the full reasoning.
  • Decisions get made, but later nobody remembers why.

If 2 of these sound familiar, one bad architectural decision costs your team more than this workshop.

Krisztián during workshops

Workshop led by

Krisztián Papp

Software architect & consultant

10+ years of hands-on experience · international conference speaker · DevOps / architecture / cloud focus · small-group practical workshop

What your team leaves with and uses the very next day

  • An ADR template your team can use to document a decision in 15 minutes, still clear six months later.
  • A decision matrix (reversible / system-level / expensive) that helps decide in 5 minutes whether a formal decision is needed at all.
  • Your team can defend its decisions in tense discussions — without freezing on the “why this way?” question.
  • You can explain the same system to leadership and to a junior engineer — with the same diagram, at different levels.

Frequently asked questions

Who is this workshop for?

It's for engineering teams, tech leads, and engineering managers who regularly make technical trade-off decisions.

It's a good fit if your team balances legacy and modern systems, and you want your decisions to stay defensible six months later.

Does the team need prior experience?

Yes — participants need basic professional development experience.

It's not for absolute beginners, but not only for seniors either — what matters is that the team has faced real architectural problems, not just tutorials.

What team size does this work for?

We keep the hands-on groups small so people can actually ask questions and discuss, not just sit and listen.

We figure out the right group size together during the consultation — for larger teams, we split the hands-on work into smaller groups.

On-site or remote?

Both work: at your office, or remote, depending on where your team is and what fits best.

We settle on the date and format during the consultation.

What does it cost?

Price depends on team size, format (on-site or remote), and how much customization you need.

Send us the details and we'll put together an exact quote.

Will there be a recording?

Not by default — this is an interactive workshop, not a lecture, and that's where most of the value comes from.

If a recording matters to your team, we can discuss that during the consultation.

What will the team actually learn?

We work through real examples: system design decisions, understanding trade-offs, typical pitfalls and how to avoid them — tailored to your own systems.

It's not a theory-only talk — it trains how the team thinks.

Let's set this up for your team

We tailor the workshop to your stack, your systems, and your current challenges — on-site or remote, matched to your team's size and schedule.

Example program (customizable)

Day 1 — Decisions and ADRs

  • 09:00 – 09:20
    Introduction

    Short intros and context. You walk through the workshop arc: from a problem to a decision, then to documented change.

  • 09:20 – 10:30
    Structuring decisions

    You learn to state a problem clearly, surface options, and decide along trade-offs. You run through one shared example together.

  • 10:45 – 12:15
    Your own decision situations

    You work on your own problems. The goal is that everyone leaves with one concrete, explicit decision.

  • 12:15 – 13:15
    Lunch
  • 13:15 – 14:00
    ADR fundamentals

    How a decision becomes short, readable documentation. What to focus on—and what is just noise.

  • 14:00 – 15:30
    Writing ADRs

    You turn morning decisions into ADRs. This is where it shows how clear the decision really was.

  • 15:45 – 16:30
    Review and refinement

    You read each other's ADRs, ask questions, and tighten wording so others can follow it.

  • 16:30 – 17:00
    Closing

    You recap the day and how decisions shifted while writing them down.

Day 2 — C4 and systems thinking

  • 09:00 – 09:15
    Warm-up

    Brief bridge from day 1: you have decisions and ADRs—now you look at their impact at system level.

  • 09:15 – 10:30
    Understanding the system

    How to look at a system as the outcome of decisions. What belongs in the picture, what does not, and what makes it legible for others.

  • 10:45 – 12:15
    C4 essentials

    The core of the C4 model and how to present the system at different levels.

  • 12:15 – 13:15
    Lunch
  • 13:15 – 14:30
    Shared modeling

    On one example you sketch the system together, focusing on architecture that is easy to communicate.

  • 14:45 – 15:45
    Visualizing your own system

    You draw your own systems. This is where “communicable architecture” becomes concrete.

  • 15:45 – 16:30
    Presentations and feedback

    You show diagrams to each other and give feedback on clarity and usefulness.

  • 16:30 – 17:00
    Connecting the full flow

    You tie it together: problem, decision, ADR as change, and the current system state in C4.

About the instructor

Krisztián is a software architect and consultant with 10+ years of hands-on experience. After senior engineering leadership roles, he founded his own consulting company and now helps teams make better architectural decisions using the same method he teaches in this workshop. He also speaks regularly at meetups and international conferences.

He specializes in cloud transformations, DevOps practices , architectural decision-making ( ADR ), and pragmatic system design. Krisztián is also the founder of the Letscode.hu community , creating a supportive environment where individuals can thrive, share their knowledge, and collectively contribute to the advancement of technology. The Letscode.hu podcast stays in the same lane—shorter episodes and more conversational angles—and you can tune in on SoundCloud .