Effective software architecture is not just about technological choices: it requires a comprehensive vision that integrates business constraints, technical expertise, and inter-team collaboration. However, many projects fail due to a lack of clear criteria, poor assessment of trade-offs (CAP, ACID), or a lack of knowledge of appropriate patterns (monolith vs. microservices).
This training course offers a practical approach to designing full stack architectures (backend, frontend, data):
- Defining quality objectives (maintainability, scalability).
- Choosing technical solutions (frameworks, databases, APIs) based on use cases.
- Industrializing deployment (CI/CD, containers).
All illustrated by a demo application in Java/.NET, reflecting the real challenges faced by participants.
Objectives
Evaluate and compare different software architecture approaches in order to inform technical decisions based on business objectives and project constraints.
Is it for you ?
Senior developers, software architects, tech leads, and technical project managers involved in redesigning existing applications (legacy apps), transitioning to a microservices architecture, or optimizing infrastructure performance or costs.
Prerequisite
This course requires a general knowledge of backend application development.
Your benefits
Content
This training course offers an approach to designing maintainable, resilient, and high-performance applications. It addresses the principles of application architecture from an operational perspective, linking technical choices, business objectives, and team organization. Each module is based on comprehensive use cases, with a demo application developed step by step in a Java or .NET environment.
Introduction: Quality-Oriented Architecture
Effective software architecture is based on clearly defined quality criteria, such as maintainability, testability, resilience, and performance. This module lays the foundations for quality-oriented architecture by introducing development paradigms, the role of shared objectives among stakeholders, and the importance of a common vocabulary (ubiquitous language) for structuring exchanges.
- Definition of objectives: maintainability, testability, resilience, performance, etc.
- The principle of a common language (ubiquitous language) to avoid misunderstandings.
- Paradigms: object, functional, declarative.
- Different types of applications: I/O bounded, CPU bounded.
- The IT landscape: the most widespread ecosystems.
See more + / -
Structuring code: patterns for reducing technical debt
How code is structured has a direct impact on a project's technical debt. This module examines the principles of separation of responsibilities and design patterns that are essential for a modular and sustainable architecture. It draws on the contributions of frameworks and libraries, with a view to standardizing development.
- Separation of responsibilities.
- Essential design patterns.
- Preference for stateless applications.
- The contribution of frameworks and libraries.
- Tests to guarantee
Monolithic Application vs. Microservices: Making an Informed Choice
Each project has its own constraints: business complexity, deployment requirements, team organization. This module offers a method for analyzing business contexts (bounded contexts) and functional dependencies to guide the choice between monolithic architecture and a microservices approach. It also explores possible integration models through context mapping.
- The delimitation of business contexts (bounded context).
- The respective advantages and disadvantages of monolithic applications and microservices architectures.
- Context mapping to identify dependencies and guide the choice of integration patterns.
Managing data: SQL, NoSQL, and beyond
The choice between relational (SQL) and non-relational (NoSQL) databases must take into account issues of consistency, availability, and fault tolerance, according to the CAP theorem. This module examines data access approaches, transaction principles (ACID), and the structuring of the persistence layer in relation to performance and scalability.
- Different types of databases (SQL, NoSQL) for different needs.
- The CAP theorem.
- The contribution of a connection pool.
- Data access: blocking or non-blocking.
- Transactions and ACID principles.
- The persistence layer.
Messages: integrating services asynchronously
In distributed architectures, messaging systems provide a reliable mechanism for orchestrating exchanges between services. This module presents asynchronous exchange models based on publish/subscribe, push/pull approaches, and tools such as RabbitMQ and Kafka.
- Principles and use cases.
- Message reception mechanisms: push or pull.
- Defining requirements.
- Introduction to RabbitMQ and Kafka.
Designing resilient APIs
Application programming interfaces (APIs) are a central means of communication between software components. This module explores alternative models (REST, GraphQL, gRPC) based on objectives of flexibility, performance, or load limitation (overfetching). It also examines protocols used for real-time exchanges, such as WebSocket or STOMP.
- SOAP or gRpc for exposing operations (RPC) and ultra-fast inter-service communications.
- REST for exposing resources.
- GraphQL as an alternative to REST, enabling custom queries and avoiding load limitations (overfetching).
- Publish/subscribe with WebSocket and STOMP.
Security: protecting without complicating
Ensuring the security of an application without compromising the user experience requires careful consideration. This module presents the principles of securing client-side and server-side applications, session, cookie, and token (JWT – JSON Web Token) authentication mechanisms, as well as recommendations from OWASP best practices.
- Some ergonomic best practices.
- Some eco-design best practices.
- Forms.
- Server-side rendering or client-side rendering.
- Server-side GUI implementation.
- Single-page applications for client-side development.
- Security: by session, cookie, or JWT token.
Standardizing delivery with continuous deployment
This module concludes the training by addressing deployment automation (CI/CD), containerization with Docker, and management via Kubernetes. It also introduces approaches such as serverless (serverless function), compilation methods (JIT, AOT), and the principles of the "15 Factors" methodology for cloud-native applications.
- Compilation modes: JIT or AOT.
- The "15 Factors" methodology.
- Containerization: OCI image creation, delivery on Kubernetes.
- Serverless and function deployment.
💡 Useful information
Our training sessions are offered in Montreal or Quebec City, in person or in virtual format. Dates and locations are provided when you select your session below. If you have any questions regarding registration, schedules, the language of instruction, or cancellation policies, please consult our FAQ .
Trainers
Private or personalized training
Do you have several employees interested in the same training course? Whether in person at your offices or remotely in virtual mode, we offer private training courses tailored to your team's needs. Group rates are available. Contact us for more details or request a quote online.
Request a quote