24 au 26 février, 2027
Montréal, Canada
Conférence Architecture & Design Patterns
La liste des présentations est sujette à changement sans préavis.
Architecture & Design Patterns
PHP properties are having a golden age. Since PHP 7.4, they've become steadily more powerful, and recent features like interface properties, hooks, and asymmetric visibility open up vast new potential.
So now that we have all this power, what shall we do with it? It allows us to fully rethink what it means to model data.
In this session, we'll look at PHP properties, and OOP in general, with fresh eyes to see all that they can do for us.
So now that we have all this power, what shall we do with it? It allows us to fully rethink what it means to model data.
In this session, we'll look at PHP properties, and OOP in general, with fresh eyes to see all that they can do for us.
Architecture & Design Patterns
Covers sharding functions beyond simple modulo and hashing, vertical (split) and horizontal sharding, rebalancing and resharding, and post-sharding reliability considerations. Lessons are drawn from 12 years of working with MySQL at scale and are broadly applicable to other databases. Will discuss considerations for Vitess and TiDB, many of which are likely also applicable to PostgreSQL Neki and other distributed solutions.
Architecture & Design Patterns
How much code do you still truly read? Do you check what green tests actually prove? Everything passed review without a problem, but the outage it caused is still yours. I will teach you my hard-won principles for getting this process back under control: verifying without asking, checking assumptions before building on them, ranking changes by irreversibility, actually enforcing rules. You wanted to make things predictable. Let's reclaim that.
Architecture & Design Patterns
I built a self-driving SDLC that specs, codes, tests, reviews and ships - and battle-tested Temporal, Restate, Inngest, LangGraph and DAG schedulers to get there. Durable execution wants a world that never changes; an LLM invents a new answer every call. Keep them apart - a thin controller picking the next step, model calls and file writes outside it - or a crash re-runs your expensive calls and pays twice. Here's the scorecard and the scars.
Architecture & Design Patterns
Pub/sub is a great start - but production systems need more. Explore the Outbox, sagas, scatter-gather, competing consumers, retries, back pressure and idempotency. Through practical scenarios, you’ll learn which pattern addresses which distributed-systems problem and leave able to recognise failure and scaling challenges in your own systems and choose an appropriate messaging pattern to address them.
Architecture & Design Patterns
Diffusion models excel at short clips but suffer severe drift across extended sequences. We examine agentic video frameworks that solve this orchestration bottleneck. By decoupling production into hierarchical agents for narrative planning, identity-locked keyframing, audio-driven pacing, and code-based assembly, these systems preserve continuity, offering a scalable blueprint for autonomous, long-format video generation.
Architecture & Design Patterns
Architectural choices like messaging, CQRS, and Event Sourcing often introduce eventual consistency. But users don’t want 'eventually'. They expect feedback now. In this session, we’ll explore what eventual consistency really means and look at UI and back-end patterns that provide immediate feedback without sacrificing decomposability, maintainability, or performance.
Architecture & Design Patterns
Event Sourcing is a powerful architectural pattern, but many avoid adopting it due to misconceptions about its complexity.
In this session, we will build the concepts step by step and see how they come together in a working application.
I will cover:
- Events
- Streams
- Reconstructing State
- Building Your First Application
- Common Pitfalls
In this session, we will build the concepts step by step and see how they come together in a working application.
I will cover:
- Events
- Streams
- Reconstructing State
- Building Your First Application
- Common Pitfalls
Architecture & Design Patterns
Books and workshops describe domain-driven design for greenfield code. But what about existing code? This session covers spotting code smells in anemic, procedural code, applying standard design patterns for complex behaviors and knowing when not to, and safely refactoring toward a more cohesive, domain-driven model.
Architecture & Design Patterns
Dual-writes create intermittent data inconsistencies that can be difficult to find and correct. How do you spot this anti-pattern, and how can you avoid it? This talk covers four patterns for maintaining data consistency in modern systems, prioritizing reliability and protecting developers' nights and weekends. We'll see examples in C# of each pattern, including demonstrations using SQL Server, Cosmos DB and Redis.
Architecture & Design Patterns
Le conseil dominant en frontend : décomposez tout en compound components. Chez nous, l'API publique reste volontairement simple, pensée pour des devs fullstack/backend. Cette conférence montre, à travers trois components réels (une Card neutre, un FieldBase partagé, un Combobox forké), comment décider où placer la complexité : ne rien abstraire, composer en interne, ou forker selon la nature de la divergence.
Architecture & Design Patterns
Avez-vous déjà poussé une migration BD qui a brisé la prod? Réalisé qu’un autre service brise parce qu’il utilisait votre table? Ou attendu 30 secondes qu’une BD démarre pour rouler vos tests?
Voyons une architecture de pipelines CI qui (1) teste chaque migration avant qu’elle n’arrive en prod, (2) vérifie que tous les services sont compatibles, et (3) accélère les tests d’intégration en fournissant des BD pré-migrées avec Testcontainers.
Voyons une architecture de pipelines CI qui (1) teste chaque migration avant qu’elle n’arrive en prod, (2) vérifie que tous les services sont compatibles, et (3) accélère les tests d’intégration en fournissant des BD pré-migrées avec Testcontainers.
Architecture & Design Patterns
We often talk about "the cloud" as an abstract concept, but it lives in massive, physical structures. This session strips away the jargon to show how modern data centers—the engines of the AI revolution—are actually built. We will track the journey from a vacant lot to a modern high-density compute facility. This talk will go deep into the fundamentals of creating a modern data center including how they are sized from small to hyperscale.
Architecture & Design Patterns
Open Mercato is an MIT-licensed CRM/ERP framework whose code is largely written by AI agents. As a contributor to it we can together do a tour from the outside in: specs committed beside the code, shared agent skills for pull requests, review and CI stabilization, conventions agents cannot drift from, and where humans stay in the loop. Everything is public, so we look at what holds, what breaks, and what transfers to any stack.
Architecture & Design Patterns
We have more observability tools than ever, yet every incident leaves the same question unanswered: Why? Noisy logs, SaaS tools that only react to exceptions, and sampling that drops the one request that mattered.
The problem isn't tooling, it's treating observability as logging and error reporting. This talk shows how separating data collection from relevance decisions preserves the context to also answer questions you couldn't anticipate.
The problem isn't tooling, it's treating observability as logging and error reporting. This talk shows how separating data collection from relevance decisions preserves the context to also answer questions you couldn't anticipate.
Architecture & Design Patterns
Imagine you have some legacy code. How do you actually go through and modernize the application when multiple teams are involved...and not bring down production?
In this session, you will learn real world techniques to help you with modernization. Including
Realigning product, architecture
Finding seams in your existing product
Questioning product assumptions
Making boring changes to get quick learning
Natural code expansion
In this session, you will learn real world techniques to help you with modernization. Including
Realigning product, architecture
Finding seams in your existing product
Questioning product assumptions
Making boring changes to get quick learning
Natural code expansion
Architecture & Design Patterns
A mixed-stack repository rarely feels like one application. Python, Node.js, Go, Java, and .NET services each bring their own setup and logs. Aspire gives them one place to run, connect, and report telemetry. Working examples cover service discovery, connection strings, health-aware startup, and OpenTelemetry. Learn to manage a mixed stack without replacing its tools and carry the same application model into deployment.
Architecture & Design Patterns
Recovering cloud workloads after a regional event or ransomware attack requires more than runbooks. This session covers the technical requirements for full-scale recovery and the DevOps practices that make them work under pressure: clear communication, team empowerment, and frequent experimentation. You'll learn how to build a culture of resilience that turns individual craft into repeatable, reliable recovery when disaster strikes.
Architecture & Design Patterns
What can a small Proxmox home lab teach us about disaster recovery? Using a two-node environment as a case study, this session explores how concepts such as RPO, RTO, service prioritization and recovery planning can improve resilience without clusters, shared storage or enterprise budgets. Attendees will leave with a better understanding of recovery trade-offs and practical disaster recovery thinking.
Architecture & Design Patterns
Dropping a working form or app into someone else's website is a lot more than a one-line iframe. This is a case study of how we stripped down the theme in an open source app builder to just the content, and then put back just enough so the conditional elements, form submissions and other features still worked. We'll look at origin management, session management, SameSite=None cookies, and negotiating scroll position and width with the host page.
Architecture & Design Patterns
Choosing a database is one of the most important architectural decisions we need to make as software developers — and the options have never been more plentiful. From the relational to key-value, from row-based to columnar, from SQL to NoSQL, we will examine some of the database technologies currently offered through the lens of the design choices and tradeoffs they make.
Architecture & Design Patterns
Browsers give you exactly one chance to ask a user for permission to do something. If the user declines, the only way to give access to the camera, microphone or geolocation again is hidden deep in the browser's settings (i.e. it's not gonna happen).
Once again, HTML comes to the rescue of JS. A new set of HTML elements let users give explicit permission, right from the page. We'll explore their features, their restrictions and how to use them
Once again, HTML comes to the rescue of JS. A new set of HTML elements let users give explicit permission, right from the page. We'll explore their features, their restrictions and how to use them
Architecture & Design Patterns
AI coding assistants have evolved quickly, and they are not slowing down. New models, tools, MCP servers, and techniques appear constantly, making it easy to feel like you are always behind.
Instead of chasing every new update, this session focuses on how to build one that can evolve.
I will cover:
- Understanding the context window
- Skills and MCP servers
- My agentic workflow
- Managing costs
- Systematic approach to evolving yours
Instead of chasing every new update, this session focuses on how to build one that can evolve.
I will cover:
- Understanding the context window
- Skills and MCP servers
- My agentic workflow
- Managing costs
- Systematic approach to evolving yours
Architecture & Design Patterns
This talk will review how to talk real world use cases of network architecture and transpose it on a illustration that will diagram all the important steps for lossless conceptual communication in any project. Learn to make great documents quickly with automation and developer tools to help illustrate your codebase and system architecture.
Architecture & Design Patterns
Your API was designed for a caller that reads the docs. An LLM does not. It sees an empty array and invents a reason for it. This is a talk about designing responses for a non-human caller: errors that carry a recovery plan, empty results that say whether nothing exists or you simply cannot see it, why 404 can be the wrong status code, and why one polymorphic mega-tool loses to several narrow ones. We'll look at real code from a live MCP server.
Architecture & Design Patterns
Message brokers promise scalability and reliability - but ordering complicates both. Partitions, retries, competing consumers and redelivery can all disrupt message order. We’ll explore how popular brokers handle ordering, why strict ordering conflicts with scalability, and patterns for handling out-of-order messages. You’ll leave able to decide when ordering is necessary and design systems that remain correct when it breaks.
Architecture & Design Patterns
Everyone says finding the right service boundaries is important. But how do you actually find them, what data should they own, and what do vertical slices look like in practice?
In this session, we’ll use a large retailer’s checkout process to go from identifying service boundaries to implementing them, showing how services collaborate while remaining maintainable, decoupled, and independently owned.
In this session, we’ll use a large retailer’s checkout process to go from identifying service boundaries to implementing them, showing how services collaborate while remaining maintainable, decoupled, and independently owned.
Architecture & Design Patterns
Java enums are usually introduced as a way to represent fixed sets of constants, but Effective Java also recommends a single-element enum as a safe way to implement a singleton. In this talk, I look at what happens when that pattern is used for small Java services, how it differs from classic singletons and DI-managed components, and where it starts to become a bad fit once state, dependencies, lifecycle, or testing requirements grow.
Architecture & Design Patterns
Design systems are sold as technical projects (tokens, components, doc). My conviction as React design systems dev, is different: a design system is a structure combined with a history of decisions. Through a real-life story, this talk identifies three symptoms and two root causes of failure. The conclusion highlights the need for an explicit decision-making mandate, more urgent by the rise of AI, which can sometimes lose context.
Architecture & Design Patterns
Every kill-switch you ship becomes another system to own: ownership, stale entitlements, and combinatorial tests nobody runs. I’ll walk production flag debt - rollbacks that lied, “temporary” flags that outlived the product - and leave you with a lifecycle checklist: when to flag, when to delete, and how to test without exploding the matrix.
Architecture & Design Patterns
Modern software depends on hundreds of libraries, frameworks, and services. Every dependency comes with a maintenance cost. How do you keep your software maintainable, plan a realistic maintenance budget, and decide which dependency updates and technical debt to tackle first? This talk presents practical strategies for managing dependencies and prioritizing maintenance work before it becomes a crisis.
© 2010-2026 ConFoo. Tous droits réservés. Code de conduite
Gestion des Cookies
Pour offrir une bonne expérience, l'utilisation de cookies est nécessaire. Certains sont essentiels au bon fonctionnement du site, tandis que d'autres nous aident à mieux répondre à vos intérêts.