Cloud Native Design - APIs, microservices & Kubernetes

Cloud-native systems offer flexibility and scalability, but they also introduce new complexity and architectural trade-offs.

In this training, you will learn how to build and operate modern systems that fully leverage cloud platforms such as Kubernetes and container-based environments. You will gain insight into how decisions around scalability, resilience and maintainability affect real-world systems in production.

You will work with principles such as microservices, containers (Docker), Kubernetes and platform engineering, and learn how to decouple systems to improve flexibility, independent deployments and team autonomy. The focus goes beyond individual components — you will understand how these elements come together in a working platform.

You will also explore how cloud-native architectures handle state, data and integrations, including challenges such as data consistency, distributed systems behavior and API-based communication. You will learn how to balance trade-offs between performance, reliability and complexity.

The focus is on practical application: how to build systems that not only work in theory, but remain scalable, resilient and manageable in production environments.

The course material (slides) is in English and reflects real-world practices in modern IT organizations.
This training is available as classroom training and as e-learning. Classroom sessions can be attended on-site or virtually (via Microsoft Teams or Zoom). The e-learning is fully in English and includes English subtitles.

Our training is also delivered through selected international training partners, allowing participation outside the Netherlands. Contact us for current availability and locations.

Who should attend:
This training is designed for professionals involved in designing, building and operating modern cloud-native systems.

Typical participants include:

• Software engineers
• DevOps and platform engineers
• Solution and cloud architects
• Technical management

What you will learn:

• How cloud-native architectures are structured and how they differ from traditional systems
• How to work with containers (Docker), Kubernetes and modern platform tooling
• Principles such as microservices, API design and platform engineering
• How to decouple systems for scalability, flexibility and independent deployments
• How to handle state, data consistency and integrations in distributed systems
• Trade-offs between simplicity, flexibility, performance and maintainability
• How to design and operate systems that support CI/CD and continuous delivery

Results:
After this training, you will be able to:

• Design, evaluate and improve cloud-native architectures
• Make better decisions in container- and Kubernetes-based environments
• Build systems that remain scalable, resilient and manageable in production
• Collaborate more effectively with platform teams and engineers
• Better understand and reduce complexity in distributed cloud environments
• Contribute with confidence to cloud strategy and architecture

Course Agenda

1. Cloud-native fundamentals and IT evolution: Understand the shift from monolithic systems to cloud-native architectures. Learn key principles such as stateless design, immutability, automation, scalability and the cloud-native operating model.
2. API design and API contracts : Learn how to design APIs as stable contracts using REST and OpenAPI. Understand resource modeling, versioning, error handling, backward compatibility and API governance.
3. Microservices architecture and domain modeling : Design microservices using domain-driven design (DDD), bounded contexts and loose coupling. Understand how team structure, ownership and architecture are connected.
4. Event-driven architecture and asynchronous systems: Explore event-driven architecture (EDA), messaging and streaming platforms. Understand when to use synchronous vs asynchronous communication and the impact on reliability and scalability.
5. Containers and Kubernetes fundamentals: Understand how containers (Docker) and Kubernetes work together to run modern applications. Learn core concepts such as pods, nodes, clusters, scheduling and orchestration.
6. Platform design: service discovery, API gateways and service mesh: Learn how modern platforms handle service-to-service communication using service discovery, API gateways and service mesh patterns (e.g. traffic management, observability, security).
7. Reliability and observability in cloud-native systems: Build systems that can handle failure. Learn about timeouts, retries, circuit breakers, monitoring, logging, tracing and observability in distributed systems.
8. Cloud-native security: Understand how security is implemented in modern architectures, including authentication and authorization (OAuth2, OpenID Connect), mTLS, API security and DevSecOps practices.
9. Adoption, governance and operating models: Learn how to adopt cloud-native architectures at scale, including platform teams, golden paths, API governance, and balancing autonomy with control.

Throughout the training, the focus is on real-world architectures, design trade-offs and operational considerations — not on writing code, but on understanding how modern systems are built, run and evolve in production.