I have been speaking at tech conferences since 2019, centered on how to build good systems. I have spoken on topics from resilient design principles to property-based testing to orchestration with diagrams and more.
I love to present and share my views and interact on stage. Till date, I have spoken in Berlin, Amsterdam, Copenhagen and Bangalore.
Solving Architectural Entropy With Runnable Diagrams
July 2026 - WeAreDevelopers World Congress, Berlin
"Software architecture does not age gracefully. Software architecture degrades in direct proportion to the number of changes made to the software." - Architecture of Open Source Applications, Berkley DB.
In this talk, I explore the concept of architectural entropy and how runnable diagrams can combat design erosion. Human centricity should be the core aspect of our systems and in that respect, visual thinking is a powerful construct. As the era of code generation dawns on us, systems thinking and human centricity are going to determine which systems survive and which disintegrate into chaos.
Video coming soon. Here are the slides:
Diagram driven development
October 2025 - Future of Software, Copenhagen
In this talk, I discuss how to use diagrams as the primary source of truth for system behavior, ensuring that documentation stays in sync with code and helping teams visualize complex workflows.
Untangling the API Spaghetti With BPMN Diagrams
October 2025 - APIDays, Bangalore
Microservices made our system very fragmented - we became very good at the micro-layer but quite bad at understanding how it all comes together. We often resort to white-board diagrams just to have a shared understanding. In this talk, I explain how BPMN diagrams can be the living breathing definition of how microservices interact while allowing us humans to maintain a macro-level view that is simply not possible today.
Resilience in Microservices with Congestion Control
September 2025 - Tech Summit, Amsterdam
I share my experience on how to build resilient systems that can handle traffic spikes and failures gracefully using congestion control techniques, inspired from the age-old Little's Law and TCP's design.
Avoiding Accidental Quality with Property Based Tests
September 2025 - TechExcellence Meetup, Online
I dive into property-based testing and how it helps uncover edge cases that traditional unit tests might miss, leading to more robust and reliable software. When test cases are enumerated by hand one after another, it is only a coincidende if the software works as expected because it is just not possible to enumerate all test cases. Property based tests combats this accidental nature of traditional tests by generating test cases that preserve the invariants that should never break.
Property Based Testing to Preserve Invariants
July 2025 - TechCamp, Hamburg
I demonstrate how to use property-based testing to ensure that core system invariants are always maintained, even when the failure cases are not apparent to the authors. From bugs related to daylight savings to interleaving actions from multiple users, nothing should break the invariants of a system. Property-based tests ensure this without relying on hand-crafted test case enumeration.
What Flow Metrics Teaches Us About Designing Resilient Systems
March 2025 - ScyllaDB Monster Summit, Online
In this talk, I explore the relationship between flow metrics and system resilience, and how understanding these metrics can lead to better architectural decisions.
Building Resilient Services in Clojure
December 2021 - re:Clojure, Online
Here, I focus on strategies for building robust and production-ready web services in Clojure. I discuss implementing resilience patterns such as circuit breakers, load shedding, and graceful restarts to handle high scale and ensure system availability.
Writing a fair task execution framework
February 2019 - IN/Clojure, Pune
I explore the design and implementation of a task execution system in Clojure that ensures fairness. The talk covers how to prevent task starvation and manage resource allocation effectively when executing asynchronous workloads.