Course Details
A 2-day course, 6 hours per day (12 hours in total, 09:00-16:00), delivered as lectures with workshops on a real system of the learner choosing. Beginner to Intermediate level. Almost all tools used are open source or have a free tier; learners bring their own ChatGPT or Claude account. Learners take home a prompt template set covering every stage of system analysis, sample Mermaid and PlantUML diagram files, and a system design document template. The content focuses on the thinking and the process, so it transfers to other AI tools as the technology changes.
Day 1: From Requirement to Data Model
Section 1: AI in System Analysis and Design
- The traditional SA workflow and the steps that consume the most time, which teams then skip
- What AI does well versus what still requires human judgement
- The full path: requirement, use case, process flow, ER diagram, API, architecture, test
- Diagram as code and why design work belongs in Git
- Preparing and configuring the tools for both days
Section 2: Gathering and Sharpening Requirements with AI
- The difference between business, functional and non-functional requirements
- Using AI to summarize meeting notes and extract requirements item by item
- Writing requirements that are clear, measurable and unambiguous
- Having AI find contradicting requirements and the gaps still missing
- Prioritization and requirement traceability
- Lab: turn raw meeting notes into a usable requirements document
Section 3: Use Cases and Actors
- Identifying actors and system scope before writing any use case
- Breaking requirements into use cases with main and alternate flows
- Writing complete preconditions and postconditions
- Producing use case diagrams with PlantUML and editing them as code
- Common mistakes such as use cases that are too granular or too broad
- Lab: build a use case diagram from your own requirements
Section 4: Process Flows and Sequence Diagrams
- Writing business process flows that show the order of work and who owns each step
- Using Mermaid for flowcharts and laying them out for readability
- Writing sequence diagrams to explain how parts of the system talk to each other
- Handling conditions, loops and exception cases in diagrams
- Lab: write the process flow and sequence diagram for your core process in Mermaid
Section 5: ER Diagrams and Database Design
- Extracting entities and relationships from requirements and use cases
- Setting primary keys, foreign keys and cardinality correctly
- Normalization principles and when denormalizing is the better trade
- Producing the ER diagram in Mermaid and converting it into table scripts
- Lab: design an ER diagram then create the real tables on PostgreSQL to test it
Section 6: Reviewing the Data Model Before Moving On
- Using AI to check the data model actually supports every use case written
- Testing with sample data and real queries to expose design mistakes
- Considering data volume and the indexes needed from the design stage
- Lab: review and adjust your data model until it supports every use case
Day 2: From API to Architecture and Test
Section 7: API Design with OpenAPI
- Deriving the required API list from the use cases
- REST design principles: resource naming, method selection and status codes
- Writing the spec in OpenAPI with request, response and error models
- Using AI to draft the spec and checking it covers every case
- Using the spec so frontend and backend can work in parallel before the system exists
- Lab: write the OpenAPI spec for your system and validate it
Section 8: System Architecture Design
- Architecture components: interface, processing, database and external services
- Choosing an architecture style that fits the team size and the complexity of the work
- Writing architecture diagrams in Mermaid and refining them in Draw.io
- Marking non-functional requirements on the diagram, such as security and load capacity
- Lab: sketch your system architecture and justify every component
Section 9: Test Scenarios and Test Cases
- Deriving test scenarios from use cases covering both normal and exception paths
- Writing test cases with preconditions, steps and expected results
- Using AI to surface the cases people usually miss, such as boundary values and malformed input
- Linking test cases back to requirements so coverage can be verified
- Lab: build a test scenario set from your own use cases
Section 10: Reviewing Design Quality
- Where AI typically gets system design wrong and how to catch it
- Checking consistency across requirements, use cases, data model and API
- Using AI as a second reviewer by asking it to raise questions rather than give answers
- Handling requirement changes that force a rework of the whole document set
Section 11: Delivering the Design Document
- What a system design document needs to contain for a dev team to actually use it
- Keeping diagram as code in Git and keeping documents in step with the code
- Presenting the design to executives and users without going into technical detail
- Lab: assemble a complete system design document from both days of work
Section 12: Capstone and Real-World Adoption
- Capstone: design one system end to end from requirement through test scenario
- Presenting the reasoning behind each design decision
- How to bring this process into real work and adapt it to your team
- Workshop: present your work and review the design together with the instructor