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.
Duration
2 days
Schedule
See training dates for details
Regular fee
$1,035
Preferential fee
A preferential rate is offered to public institutions, to members of certain professional organizations as well as to companies that do a certain amount of business with Technologia. To know more, please read the "Registration and rates" section on our FAQ page. Please note that preferential rates are not available for online training courses. Discounts cannot be combined with other offers.
$930
Objectives of the training
Evaluate and compare different software architecture approaches in order to inform technical decisions based on business objectives and project constraints.Targeted audience
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.Trainers
Benefits for Participants
• Define the quality criteria for an architecture (resilience, testability, scalability);
• Promote communication and alignment between stakeholders in an IT project;
• Propose an architecture adapted to business constraints and team organization;
• Choose the technologies that make up a full stack application, from back end to deployment.
Course architecture
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.
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.
Pedagogical details
Training architecture
The course alternates between theory and practice: the practical component takes the form of a "demo" application enhanced by the trainer throughout the course, which participants can use at the end of the seminar. This "demo" application can be developed in Java or .NET. Close interaction with participants will enable everyone to relate the course topics to their daily work.
Type of training
Skill development
Skill development and knowledge integration
Decision support
Basic knowledge
Private or personalized training
If you have more than 8 people to sign up for a particular course, it can be delivered as a private session right at your offices. Contact us for more details.
Request a quoteDuration
2 days
Schedule
See training dates for details
Regular fee
$1,035
Preferential fee
A preferential rate is offered to public institutions, to members of certain professional organizations as well as to companies that do a certain amount of business with Technologia. To know more, please read the "Registration and rates" section on our FAQ page. Please note that preferential rates are not available for online training courses. Discounts cannot be combined with other offers.
$930
Private or personalized training
If you have more than 8 people to sign up for a particular course, it can be delivered as a private session right at your offices. Contact us for more details.
Request a quote