Chad Green
Chad Green, Senior Systems Architect at Jasper Engines & Transmissions, brings 35+ years of experience across multiple industries. A Microsoft MVP and community leader, he drives cloud-native innovation, mentors peers, and shares knowledge through conferences and global speaking engagements.
Proposals - Montreal 2027
Island Assault Event-Driven Architecture
A demo?first, Commando?style assault on a legacy system. Each “enemy position” is a brittle synchronous call replaced with resilient event flows. We deploy producers, consumers, orchestrators, and observability in real time, add synthetic load, and show how modern EDA patterns stay steady under fire—with minimal slides and maximum action.
Technical Debt Is Not Free
Technical debt piles up unnoticed, and even documented debt is useless without action. This session shows how to identify, track, and prioritize debt, then apply practical remediation strategies to help teams avoid hidden risks and keep small issues from becoming costly failures.
Navigating the Maze of Communicating Architecture Decisions
ADRs make the “why” behind architecture explicit. Learn how to document context, rationale, and consequences; maintain ADRs over time; and communicate decisions clearly. Real examples and best practices help architects and developers express design reasoning with confidence and shared understanding.
In Defense of Microservices
Despite growing skepticism, microservices still offer major advantages when applied in the right contexts. This talk covers their strengths, the strategies that tame complexity, and comparisons with monolith, n?tier, and modular monolith designs—grounded in lessons from real implementations.
Architect Like a Boss: Mastering Serverless Design Patterns
Master the serverless patterns that separate hobby projects from production systems. Explore event?driven design, async workflows, and error?handling strategies that build scalable, resilient, cost?efficient apps. Whether new or experienced, you’ll leave ready to architect serverless solutions with clarity and confidence.
Discover Real Power in Azure Functions Beyond Hello World
Step past “Hello World” and into Azure Functions’ deeper capabilities. This talk showcases alternative triggers and bindings, real?world demos, and patterns for solving complex business workflows. Attendees leave ready to build scalable, resilient, innovative serverless applications.
Contract-First APIs in the Age of AI Agents
AI agents are becoming first-class API consumers and far less forgiving than humans. Today, contract-first design isn’t just a best practice; it’s the only way to keep your APIs discoverable, predictable, and safe for autonomous orchestration.
Transform Chaos into Order with Azure Durable Functions
Azure Durable Functions turns chaotic, long?running workflows into resilient orchestrations. This session shows how to manage state, handle failures, and scale complex business processes through step?by?step demos and best practices, giving teams patterns to modernize legacy systems and build robust serverless applications.
Infrastructure as Documentation
Most IaC becomes opaque because it doesn’t encode intent. This talk shows how contract?first Terraform makes boundaries and assumptions explicit, offers patterns usable across IaC tools, and includes a live refactor of a messy module. Attendees leave with scalable, self?documenting infrastructure practices.
Platform Engineering Without the Fantasy
Platform engineering fails when built on fantasy. Overbuilt, under?adopted platforms stem from vague contracts, fuzzy boundaries, and vanity metrics. This session shows why self?service backfires, how CI/CD becomes a choke point, and how contract?driven surfaces, user?journey workflows, and real value measures create platforms teams actually use.
Architecting With AI: From Requirements to Reality
AI expands architects’ thinking, clarifying requirements, generating options, and stress?testing assumptions. This session shows how to steer AI toward constraint?aware analysis, avoid hallucinated designs, and turn AI output into durable artifacts like ADRs and decision logs for responsible, repeatable architecture.
Observability for Asynchronous Systems
In async systems, work spans queues, timers, and retries, so tracing requests fails. Learn how to model intent as telemetry, design causation?aware traces, and build durable visibility across services. See Azure Monitor patterns and a live teardown that turns opaque async failures into explainable workflows.
Serverless Beyond the Happy Path
Serverless promises ease, but production brings retry storms, poison messages, cold starts, and brittle deployments. Learn how functions actually behave under load, how to detect dangerous patterns through observability and cost signals, and how to harden apps with safe versioning, failure handling, and isolation.
Idempotency, Exactly?Once, and Other Lies We Tell Ourselves
“Exactly?once” and “idempotent” guarantees collapse the moment systems fail. This session shows why duplicates, retries, and partial writes are inevitable, and how real idempotency, safe state transitions, and recovery patterns keep workflows correct when messages replay and failures cascade.
Event Contracts Are Forever
Event schemas are long?lived public contracts, not disposable payloads. This session shows why “non?breaking” changes still break consumers, and how additive evolution, envelopes, metadata, ownership, and governance create event contracts that survive real change without fear or version chaos.
Event-Driven Architecture Without the Fairy Dust
Event?driven architecture isn’t fairy dust. “Just emit an event” leads to fragile systems, hidden coupling, and schema drift. This session shows how contract?first design, clear ownership, and compatibility rules create durable, business?focused events that evolve safely and avoid platform?wide blast radius.
