You'll start by designing the foundational domain layer, focusing on creating rich business logic through entities, value objects, and domain services. From there, you'll build application logic with well-defined use cases, ensuring clear separation of concerns. We'll introduce the CQRS pattern to effectively manage commands and queries, utilising the Mediator pattern to streamline interactions between components. Finally, you'll develop a robust Web API, integrating these elements to create a solution that's functional and ready to handle real-world scenarios.

This workshop is designed for developers who want to master Clean Architecture and DDD in practice. It offers immediate takeaways you can apply to your next project. By the end of the day, you'll have built a strong foundation for testable, maintainable, and flexible enterprise-level systems with .NET.

1 Day

22 April

Practical Clean Architecture and DDD with .NET

Architecture

.NET

This workshop takes you through the OWASP LLM Top 10 and MCP security via hands-on hacking labs. You will exploit real LLM application vulnerabilities and learn how to implement robust secure design patterns. Whether you build or break LLM applications, this workshop is for you.

We finish with a high-energy attack and defence wargame. Plenty of learning and fun, guaranteed.

This opening module walks learners through recent real-world LLM security incidents and introduces the OWASP LLM Top 10. It gives attendees a fast, confidence-boosting overview of how and why AI applications fail and which threats matter most.

- Recent attacks and exploits
- Introduction to the OWASP LLM Top 10

Participants dive into the most notorious LLM vulnerability. They learn how prompts are manipulated, explore different attack styles, and complete hands-on labs for identifying, exploiting, and remediating prompt-injection flaws.

- Introduction to prompt injection
- Prompt injection types
- LAB: Identification, exploitation, remediation

Module 2 - LLM05: Supply Chain Vulnerabilities

A deep look into the ML supply chain (TensorFlow, SciKit, etc.) and the risks of loading untrusted models or components. Learners observe malicious model behaviour, exploit poisoned artefacts, and apply hardening measures.

- Insecure deserialisation
- Introduction to TensorFlow
- Introduction to SciKit
- Handling untrusted ML models
- LAB: Exploiting malicious SciKit
- LAB: Exploiting malicious TensorFlow
- LAB: Securing TensorFlow and SciKit

This module examines the MCP protocol and the new attack surface it introduces. Learners explore attacks such as tool poisoning and cross-server tool shadowing, and apply practical defences.

- Introduction to MCP security
- Tool poisoning
- Cross-server tool shadowing
- Line jumping, tool collisions, etc.
- How to protect against them

A competitive wargame where participants attack and defend AI apps using everything learned throughout the workshop. This is consistently rated the highlight of the day.

- Attack and defence contest: prompt injection and prompt engineering

- Understand the OWASP LLM Top 10 and MCP security through practical exercises
- Gain hands-on experience with real LLM threats and exploitation techniques
- Learn how to implement effective security controls for LLM applications

- MacBook, Linux laptop, or Windows laptop with WSL/VM
- Docker, git, and make installed
- Latest version of Firefox, Brave, or Chrome
- A passion for learning

- Certificate of completion
- Access to all theoretical and practical workshop content
- Access to all labs, exercises, and challenges locally and on the SecDim wargame platform
- 2 months of additional self-paced git-based labs on the SecDim wargame platform
- Access to a private Q&A forum for post-workshop questions

Attack and Secure AI Apps - Wargame Edition

Security

As a consequence, we extensively use HTTP as a protocol throughout our systems without considering its limitations.

Even though we might leverage syntactic sugar like async/await when we implement communication between our system’s components, HTTP protocol has a synchronous nature.

This limits our options when it comes to choosing a communication pattern or introducing very important quality attributes like resiliency, fault tolerance, or temporal decoupling.

We overlook some of these architectural aspects until is too late, and we learn the hard way that we need them.

In this workshop, we will start with a ‘traditional’ RESTful API and make the necessary changes to introduce asynchronous messaging, all with an eye on non-functional requirements.
This is a hands-on workshop, so be prepared to write code!

By the end of the workshop, you will know how to evolve your architecture from simple to complex, from RESTful to messaging-based, that has all the extra aspects that messaging brings..

Introducing asynchronous messaging in a system is not an easy task. Sometimes, we have to unlearn what it means to do a simple Request/Response using HTTP so we can progress. Exactly this is what happens here.
We will see what are the usual steps to do that, and what transformations we have to do in our arhitecture, to accommodate this.

We will deep dive into a new world that covers queues, topics, message brokers, different abstractions, and patterns like outboxes or sagas specific to distributed systems.




- Why API design matters
- How we address the NFRs
- what makes a good API
- Pub/Sub
- Commands
- Request/Response with messaging
- Dealing with errors
- Reliability
- Error Handling
- Fault tolerance
- Resilience tactics
- Outbox
- Sagas
- Routing Slips
- Observability




This is a Bring Your Own Device (BYOD) workshop. Therefore, attendees are required to bring their device with the necessary software already installed:

- Need to have Visual Studio, or an IDE you are familiar with
- .NET 9 or higher
- Docker
- Github
- RabbitMQ installed as a standalone instance, or we will install it in Docker




- The workshop targets .NET Software developers who want to have a more architecture-focused approach
- C# developers who want to understand the communication patterns and the best practices for APIs in distributed architectures.



At the end of this workshop, you will be able to:


- understand which APIs are best suited for which scenarios
- understand what are the non-functional requirements needed for production-ready APIs
- evolve a ‘traditional’ architecture to a more complex one that uses asynchronous messaging
- Understand what asynchronous messaging brings to the table and where it can benefit our distributed systems

From REST to Async Messaging

Through real-world examples and practical exercises, you'll gain the tools to recognize security blind spots in distributed systems and apply patterns that harden your architecture without sacrificing developer productivity.



Why traditional perimeter-based security fails in microservices

Designing clear service boundaries for least-privilege communication

Securing message brokers and asynchronous communication patterns

Identity propagation, impersonation protection, and access control

Techniques for dealing with token expiration

Partial security for message personalization

Logging, audit trails, and anomaly detection in a Zero-Trust environment

Software engineers, architects, DevOps, and platform teams building or maintaining microservices-based systems.

This workshop is ideal for those seeking to implement modern security models like Zero Trust while maintaining flexibility and performance across distributed architectures.




This is a Bring Your Own Device (BYOD) workshop. Attendees must bring their own device with the latest .NET SDK installed. You’re free to use any IDE of your choice.

Securing Microservices with Zero Trust

Cloud

Microservices

Introduction to Model Context Protocol and its business applications

Core MCP concepts: Server/client architecture, agents, resources, and tool calling

Hands-on exercise: Building a local MCP server

MCP Apps: Creating interactive AI-powered applications

MCP Clients: Building your own host applications

RAG basics: Giving your MCP server a knowledge base

Deployment options: Remote MCPs, cloud providers and hosting alternatives

Basic Python or JavaScript programming knowledge

Familiarity with AI/ML concepts (helpful but not required)

Laptop with necessary development environment

This training is targeted at developers and people with a medium+ technical skill level and interest for AI.

 
Bring your laptop with your preferred IDE and either Python or Node installed. We recommend an AI-coding agent like Claude Code, Cursor or GitHub Copilot, but not required!

 
You need access to an LLM provider like OpenAI or Azure Foundry, but you can also use Ollama if you would like to run everything locally and free.

Context Is King: A Hands-On MCP Workshop

This full-day workshop is for developers, architects, and technical leaders responsible for delivering AI solutions that create real business value. Drawing on lessons learned from delivering enterprise AI systems across government, education, finance, and healthcare, the session explores what consistently works, what commonly fails, and why.


Attendees will examine real-world AI architectures, learn how to prioritise use cases, choose between pro-code, low-code, and third-party AI tools, and understand how emerging platforms such as Azure AI Foundry and Microsoft Fabric fit into today’s delivery landscape. The focus is practical and experience-driven, equipping participants with the decision frameworks needed to build AI systems that scale, comply, and deliver measurable ROI.

NDC { Sydney }

Workshops

09:00 - 17:00 (UTC+11)

Delivering Enterprise AI: From Architecture to Real-World ROI

Adam Stephensen

Practical Clean Architecture and DDD with .NET

Jason Taylor

Attack and Secure AI Apps - Wargame Edition

Pedram Hayati

Context Is King: A Hands-On MCP Workshop

Aleksander Stensby

Securing Microservices with Zero Trust

William Brander

From REST to Async Messaging

Irina Dominte(Scurtu)