Speaker kit

Domain-Driven Design is a well-accepted approach to building large systems with maintainable codebases. It provides both strategic and tactical patterns for software development. This talk focuses on tactical patterns with a pragmatic approach, explaining how to layer your software and implement aggregates, repositories, domain services, application services, and other fundamental building blocks through real-world examples and clear guidelines.

The solution structure and code samples are based on .NET and C#, but this talk will be valuable for developers and architects working with any server-side technology.

Building a monolith first is a highly recommended approach for new solutions, even if your goal is to build a microservice solution in the end. One major reason is that requirements and service boundaries are not clear in the beginning, and playing with the service boundaries is not easy in a distributed system as it is in a monolith application.

In this talk, I will clearly explain and offer a well-defined approach to build a modular monolith application that is easy to transform into a microservice system later.

Microservice architecture is a quite common approach to build highly scalable solutions with a large development team. While there are standard tools, like Kubernetes, to deploy, run and scale your microservices, the development side is not as mature as that. It is not easy to develop, run and test a single microservice that depends on other microservices and services. Running a copy of the entire system in the developer's machine is impractical.

In this talk, I will introduce an efficient way of creating a development environment that is well integrated to Kubernetes. In this way, you can just run the microservice you are building and let Kubernetes run all your dependencies in your local machine or a remote server.

Designing a truly dynamic data model is one of the most challenging tasks in modern application development. Many teams fall back to traditional approaches like Entity-Attribute-Value (EAV) or overly generic schemas, only to struggle later with complexity, performance bottlenecks, and maintainability issues. In this talk, we will explore the landscape of dynamic entity systems, compare alternative patterns, and highlight their strengths and tradeoffs, before zooming in on how Entity Framework Core can be leveraged to build something both flexible and efficient.

Drawing on real-world experience from building the low-code capabilities in ABP Framework, I will share the key architectural decisions, pitfalls, and solutions that made our dynamic entity system robust and performant. You'll see how EF Core's extensibility can be pushed to its limits, how to handle querying and schema evolution at runtime, and how to avoid common traps while maintaining developer productivity.

In this session, I will introduce the multi-tenancy pattern, which is a widely accepted approach for SaaS application development. Then I will show how you can build multi-tenant applications with .NET using the ABP Framework. We will mostly focus on isolating users, roles and other data of tenants while they are located in the same database and accessed by the same application instance.