Skip to content

Design

Model and Architect the System

A good model tells you what to build; this workshop covers both modeling it and turning it into how. Most teams jump from requirements straight to code, and the architecture ends up being whatever the first few commits made it. Design closes that gap.

At the heart of it is the MOSY Framework, the visual notation that chains one thing to the next: business goals to product functionality, functionality to a conceptual data model and to technical components. It's what keeps new functionality aligned with your current architecture and with the business as the system grows, instead of drifting a little further with every feature. From the model you'll draw architecture diagrams, set boundaries and ownership, and make the service decisions deliberately: how many services, sync or async, events or direct calls, and the trade-offs behind each. The same approach works greenfield or carving a monolith into something that can evolve.

You'll capture the important decisions as ADRs so the architecture stays explained, not tribal knowledge, and you can plug it into an Architecture Community so the team takes part. You leave with a model, an architecture drawn from it, and the decisions recorded: a build-ready plan the Build workshop (and its AI agents) turn into working software.

What You'll Learn

How to design a system end to end: model it with the MOSY Framework (the notation that chains business, functionality, data and components and keeps them aligned as you add features), draw the architecture diagrams, and turn the model into components with the service decisions made on purpose. You'll record decisions as ADRs and work the trade-offs of greenfield versus refactor, ready to feed AI coding agents.

Who Benefits Most

Software Architects and Tech Leads who turn intent into a buildable system. Developer representatives who want the model and the architecture decided together. Teams modernizing a monolith or starting fresh who want the design on purpose, not by default.

Key Outcomes

A model of your system in the MOSY Framework. An architecture from that model: components, boundaries and the service decisions made and justified, recorded as ADRs. A build-ready plan your team and AI agents can start from.

What You Need

Your laptop and a system or feature to work on (or use my scenarios). I provide a board for the visual work. No setup and no coding: this is a design workshop.

Workshop Details

Duration duration TBD
Format Interactive Workshop
Level Intermediate
Group Size 20 max participants
Target Audience Architects, Tech Leads, developer representatives

Upcoming Sessions

Online Workshop

Waitlist
Online cohort: dates to be announced
Online (Google Meet)

Get notified as soon as the online cohort opens.

In-Company Training

Available Now
On-demand - Contact me
Your Office or Online

Private workshop for your team. Customized content and flexible scheduling.

Request Quote

What You'll Master

Model the system with the MOSY Framework and turn it into an architecture your team and your AI agents can build, with the decisions made on purpose and recorded.

Model the system with MOSY

Learn the MOSY Framework: the visual notation that connects business goals, product functionality, a conceptual data model and technical components in one model everyone reads. It's the thread that keeps each new feature aligned with your current architecture and the business.

Turn the model into components

Map functionality to a clear component architecture: what each component owns, how they connect, where the boundaries are. Make the service decisions on purpose: how many services, sync or async, events or direct calls, and why.

Record the decisions (ADRs)

Draw architecture diagrams and capture the decisions behind them as ADRs, so your architecture stays explained instead of living in a few people's heads. Plug it into an Architecture Community so the team contributes.

Hand a build-ready architecture to AI

Produce a structure your AI agents can build from. The StrategyRadar agents (mosy-system-architect, task-coordinator) turn the result into work in the Build workshop.

Workshop Agenda (timings being finalized)

Session 1 TBD

BLOCK 1: Model with MOSY

The notation and the high-level model

Goal: Model the system with the MOSY Framework and keep business and architecture aligned
  • The MOSY Framework notation: actors, actions, entities, objectives, technical components
  • The high-level model and the thread that aligns business with architecture
  • How the model stays aligned as you add new functionality
Session 2 TBD

BLOCK 2: From Model to Architecture

Components, boundaries and the service decisions

Goal: Turn the model into a component architecture decided on purpose
  • Map functionality to components: ownership, boundaries, connections
  • Service decisions: how many services, sync or async, events or direct calls, and the trade-offs
  • Greenfield or refactor: pragmatic, incremental paths
Session 3 TBD

BLOCK 3: Record and hand off

Diagrams, ADRs and a build-ready plan

Goal: Capture the decisions and produce a plan ready for Build
  • Architecture diagrams from the model
  • Architecture Decision Records (ADRs) and the Architecture Community
  • A build-ready plan the Build workshop and its AI agents turn into software
Moisés Macero

About the Instructor

Moisés Macero

Software Architecture Consultant

Creator of the MOSY Framework, the visual modeling notation at the heart of the MOSY Method. With 20 years of experience taking systems from business intent to working software, from monolith extraction to event-driven and microservice architectures, now with AI across delivery.

Get in Touch

Want to run Design with your team, or talk through modeling your system and taking it to architecture? Tell me about your system and I'll get back to you.