Presentations

Robert will demonstrate how they used the Claude API to create a natural language interface for simple FreePBX configuration requests as proof of concept (POC). He will also discuss plans to expand this functionality for the Tekmetric Phones service, with the goal of reducing the workload on support staff.

Follow along as we deep dive into a real-world transaction wraparound incident, discuss recent Postgres innovations, and explore features like index de-duplication and autovacuum enhancements designed to help eliminate the problems. We'll talk about how to optimize your Postgres environment and make a strong case why upgrading might just eliminate your XID wraparound risks.

A vCon (virtualized conversations) is a standardized, machine-readable container for data from any type of human conversation, such as a phone call, video conference, or chat. Developed by the IETF, it standardizes how conversational data, including audio, video, text, metadata, and attachments, is collected, stored, and shared across different systems. Attend this session to get an overview of this area, the possibilities and security implications. We'll also look at a couple of ways to have Asterisk create vCons for you.

When I first started learning Vitess, I quickly realized how much it could do beyond just scaling MySQL — from built-in high availability and transparent query routing to online schema changes and resharding. In this session, I’ll share what I’ve discovered as a newcomer exploring Vitess, how easy it is to get started, and why it’s becoming a go-to open-source solution for running MySQL at scale.

What do looms, Linux, and open-source communities have in common? More than you might think. This talk uncovers the surprising computational depth of textiles where patterns function like algorithms, fabrics behave like data structures, and some of the earliest programmable machines were built.

Attendees will leave with a new understanding of how deeply computation is rooted in craft and why the cultural values of repairability, transparency, and user modification link weavers and open-source developers across centuries. If you’ve ever wanted to see computation from a completely different angle, this talk will change how you think about both craft and code.

Tired of sky-high logging costs and vendor lock-in, ZipRecruiter migrated from Logz.io to Grafana Loki. This talk shares the real challenges, unexpected pitfalls, and hard-won victories from our journey. Learn what worked, what didn't, and what we wish we'd known before starting. From sizing clusters and dealing with cardinality explosions to convincing skeptical engineers, we cover the messy reality behind the marketing slides. You'll leave with practical insights and battle-tested strategies for running Loki at scale.

File upload vulnerabilities in cloud-native apps are often underestimated, but a flaw in Streamlit’s st.file_uploader enabled attackers to bypass client-side checks, upload arbitrary files, and seize control of misconfigured cloud instances. This talk walks through the full exploit chain—from bypassing file filtering to gaining persistent access and manipulating live data pipelines—revealing how simple oversights can lead to market-scale risk and why trusting frontend logic is a dangerous mistake.

Ever been curious how those weather forecasts you get on your phone and on the news are created? Welcome to the wonderful world of chemical transport models (CTMs), the largely open source software behind modern weather and air-quality prediction. Modeling agencies and numerous state and local environmental offices rely on systems like the Weather Research and Forecasting model with Chemistry (WRF-Chem) and the Unified Forecast System (UFS) to simulate how gases, particles, and meteorological conditions evolve in the atmosphere. UFS provides large-scale, global weather analyses and forecasts that supply essential boundary and initial conditions, while WRF-Chem couples weather dynamics with detailed chemical processes to resolve regional air quality with high spatial precision. Together, these models allow weather agencies, and now you, to translate complex atmospheric science into the clear, timely information that allows us to anticipate rain, model winds, or predict pollution events using our trusty Linux machines. Come learn how WRF-Chem works: how to customize it to run over your area, the kinds of openly available inputs it uses to establish initial and boundary conditions, and examples of how the generated predictions compare to real-world outcomes.

Welcome and introduction to the Kwaai Summit from Ted Cohen followed by a brief introduction to Kwaai and the Personal AI Community by Reza Rassool.

The classic Java mantra, "write once, run anywhere," suggested that developers should be able to rely on the JVM to handle the intricacies of different hardware environments. For all modern high level languages, we expect compilers and language runtimes to “abstract away” the hardware for application developers. However, the hardware can still impact application performance. Developers and architects should know enough about the behavior of the underlying hardware to avoid pitfalls and take advantage of opportunities to maximize performance. 
 

In this talk, you will learn about: 

- How modern CPU pipelining and memory models can impact application performance
- Why Arm64 instances typically offer the best price/performance on modern cloud platforms
- Arm64 features you can leverage to improve performance 

This session is ideal for software developers who want to understand how server architecture influences application performance, and how to make informed decisions about the underlying architecture when deploying applications to the cloud.

What is a developer platform anyway? Who should have one? What makes a good platform? How will you maintain it? Should you use Kubernetes? Vault? Mise?
Rather than recommend a specific set of technologies, this talk is about recognizing the common building blocks and best practices when building and maintaining a developer platform.
You will learn that there are common patterns and realize that you very likely already have what it takes to build a great developer platform!
 
 

Kubernetes is a popular place to run databases. The deployments increasing comes in the form of database-as-a-service platforms for developers. This talk walks through the design of a Kubernetes DBaaS, based on our real-world experience building and operating SaaS platforms for analytic databases. We cover implementing the database environment on Kubernetes, monitoring, and public APIs for developers to provision and manage databases for themselves. There's also guidance on issues like upgrade, backup, and multi-tenant operation. The talk supplies everything you need to start building a database platform of your own.

PostgreSQL 18 is currently the latest-and-greatest PostgreSQL
version to be released. This talk will take a quick look at many of the new features in this version, and why it's time to upgrade if you haven't already.

The open-source AI ecosystem is growing fast, with thousands of pre-trained and fine-tuned models readily available for reuse. This accessibility also introduces inherited risks, including data poisoning, backdoors, and model tampering that can propagate silently through the AI supply chain. This talk explores how Artificial Intelligence Bills of Materials (AIBOMs) can provide visibility, accountability, and better security practices for open-source AI, helping developers and organizations trust what they build on.

As AI agents gain the ability to plan, adapt, and even rewrite themselves, they introduce both new power and new risk to software delivery. This talk looks at real incidents and emerging research to show how polymorphic agents can reconfigure behavior, bypass constraints, and challenge assumptions about “safe” automation. Attendees will learn to recognize red flags and rethink quality in a world where tools don’t just follow instructions—they evolve.

AI coding agents can generate application code, but safely operating cloud infrastructure is a different game. This talk explores what happens when you give AI agents real infrastructure access: the patterns that work, the failures that teach you humility, and the emerging protocols that might make this actually viable.

We explore how containers have empowered teams and transformed collaboration while also becoming an unquestioned default in many workflows. This talk reflects on where containers have genuinely improved developer experience and reliability, where we adopted them out of convenience rather than design, and how newer tools and patterns can help simplify today’s increasingly complex stacks. It invites attendees to revisit long-held assumptions with empathy, not to replace containers but to use them more intentionally, and it offers a human-centered perspective on building systems and teams that thrive.

What really happens to a single INSERT in PostgreSQL once it enters the system? In this talk, we trace the complete lifecycle of one tuple as it travels through PostgreSQL’s logical replication pipeline. Starting at the executor, we watch the tuple become a WAL record, explore what changes when wal_level=logical, and reveal how the logical decoding layer reconstructs row-level changes from low-level WAL fragments. We’ll step through the inner workings of the ReorderBuffer, explain how replication slots guarantee durability, and show how output plugins convert decoded changes into a logical stream ready for subscribers.

On the receiving side, we follow the apply worker as it processes transactions, resolves ordering, handles conflicts, and replays the change into the subscriber database. By the end, you’ll have a clear mental model of each stage—from WAL generation to apply—and a deeper understanding of how PostgreSQL reliably moves data through logical replication.

Whether you run logical replication, build CDC pipelines, or simply want to understand the internals behind one of PostgreSQL’s most powerful features, this talk will give you a guided, intuitive, and highly practical look behind the scenes.

Internet-in-a-Box (IIAB) “learning hotspots” serve dozens of countries, e.g., in remote mountain villages in India, over a local Wi-Fi hotspot, bringing Wikipedia, Khan Academy, healthcare libraries, and OpenStreetMap (OSM), all without the need for internet or a mobile data plan. Come and see the NEW IIAB Maps. Anyone can self-host and customize to the region they need—including vector tiles, mountain relief topography tiles, and satellite photo tiles—all with powerful full-text search. Our new IIAB Maps are flexible and customizable, robust, offline-first, and localizable to help almost anyone, anywhere!

No one wants to be responsible for breaking the build. But what can you do as a developer to avoid being the bad guy? How can project leads enable their teams to reduce the occurrence of broken builds?
In talking within our own teams, we discovered that many developers weren’t running sufficient integration and End to End tests in their local environments because it’s too difficult to set up and administer test environments in an efficient way.
That’s why we decided to rethink our entire local testing process in hopes of cutting down on the headaches, heartaches, and valuable time wasted. Enter Kuttl. Connecting Kuttl to CI builds has empowered our developers to easily configure a development environment locally that accurately matches the final test environment without needing to become an expert CI admin themselves.
These days, we hear, “Who broke the build?” far less often and you can too!

Everyone wants to work on what matters most, yet many engineers struggle to see how their work aligns with company goals. In this talk, we show how radical transparency can correct organizational misalignment. By opening roadmaps, decision histories, customer feedback, and internal documents, teams and individuals gain clarity and autonomy.

We've analyzed over 1 million production K8s failures across thousands of clusters. The data reveals something striking: the vast majority of incidents fall into predictable, preventable categories. By the law of large numbers, if we address these recurring issues, we can drastically improve production reliability.

This is a hands‑on workshop showing how a browser tab can become a secure, full‑fledged development environment for open source AI. Kasm Workspaces is a container‑streaming platform that delivers Linux and Windows desktops, IDEs, and browsers straight to any modern web browser, with no local installs, VPNs, or agents required.
 

In this three-hour workshop (with time for plenty of Q&A!), Joe Thompson walks you through container images from their most primitive forms through building modern OCI images, explaining concepts along the way. As you work through the exercises, we'll discuss the effects of different build techniques and styles on maintainability, deployment and security, and you'll learn about image basics like layers, tags, and signatures as well as more nuanced concepts like strategies for determining how to build and use your own base images while allowing for effective use of tools like image security scanners. Whether you're a beginner to containers or an experienced builder who wants to further explore the details most build tools abstract away, this workshop will have something for you.

Kubernetes Cluster API (CAPI) has emerged as the standard for declarative, GitOps-driven management of Kubernetes clusters. In this session, we will peel back the layers of the CAPI to reveal how its core controllers, webhooks and CRDs work together to reconcile your desired cluster state. You’ll discover how Machine and Infrastructure Providers translate high-level specifications into real infrastructure—whether on AWS, Azure, vSphere or even bare-metal. We’ll examine the mechanisms that enable automated cluster creation, scaling and rolling upgrades, and explore health-checking machines so that failures are detected and remediated automatically. By the end of the session, you will understand why Cluster API is far more than a collection of CRDs, and you will leave with concrete examples and code snippets ready to integrate into your CI/CD pipelines, empowering you to manage production-grade clusters with confidence and precision.

We'll also scratch the surface of next steps on enabling true platform engineering utilizing CAPI and its friends in the ecosystem.

In this hands-on workshop, participants will learn the theory behind ClusterAPI and gain real hands-on experience via a pre-created lab environment. To complete the lab exercises, you'll only need your browser.