Sessions

Kick off Chris Con 2026: what's new this year, how the four days are structured, where to find the workshops and open space, and how to get the most out of the hallway track.

AI systems that plan, write, and review code are no longer a novelty — they're a coworker. This keynote looks at what a decade of reasoning machines means for how we architect systems, grow careers, and decide what "engineering" even is. No hype, no doom: a field report from teams already living in that future.

HTTP/3 and QUIC are now the default on most major CDNs — but what actually changes for your app? A practical tour of what the new transport gives you (and what it quietly takes away): connection migration, head-of-line blocking, load balancer gotchas, and how to measure whether it's helping your users at all.

Staging is where confidence goes to die: it's never quite production, and everyone knows it. This talk makes the case for replacing the shared staging environment with ephemeral preview environments, production traffic replay, and progressive rollouts — and walks through how we actually did it, including the two months where everything was on fire.

Threat modeling doesn't need a security team or a two-day offsite. In this workshop you'll threat-model a realistic web application in small groups using a lightweight, repeatable method you can run in a one-hour team meeting. Bring a laptop; leave with a filled-in template and the confidence to run it at work next week.

The View Transitions API promises native-feeling navigation on the web — but the demos are all image galleries. This talk covers three production rollouts: a content site, a dashboard, and an e-commerce checkout. What worked, what janked, how we measured it, and the CSS you'll wish someone had shown you first.

Modern apps ship more third-party code than first-party code, and attackers noticed. This deep dive dissects three real-world dependency compromises — how they got in, how they were caught, and the checks that would have stopped them. Covers lockfile hygiene, provenance attestation, and a pragmatic review process for the packages that matter.

Everyone has an AI demo; far fewer have an AI feature that survives real users. This panel brings together three practitioners shipping LLM-powered products to talk honestly about evaluation, cost, guardrails, and what changed in their engineering practice. Moderated, with plenty of time for audience questions.

How three engineering teams cut their lead time from days to hours by rethinking their CI/CD pipelines. A practical walkthrough of caching strategies, test sharding, and progressive delivery — with real numbers from real migrations.

Fernwood Robotics grew from 12 engineers to 400 without losing the things that made it work: small teams, written decisions, and a healthy on-call. This keynote is an honest tour of what scaled, what broke, and the three cultural bets that mattered more than any org chart.

On-call doesn't have to mean dread. Over two years we rebuilt our rotation from the ground up: alert budgets with teeth, a "no heroics" escalation culture, daytime-only pages for non-critical services, and honest postmortems. Pages dropped 70% and nobody quit. Here's the exact playbook, including the parts leadership pushed back on.

Feature flags are the duct tape of modern delivery: essential, and a mess if you never clean them up. This talk proposes a lifecycle for flags — created with an expiry, monitored for staleness, and deleted by CI when they've fully rolled out — and shows the tooling we built to take our flag count from 800 to 90 without a single incident.

Our inference bill grew 40x in a year — then we cut it by two thirds without hurting quality. A deep dive into the mechanics of LLM serving costs: caching and batching strategies, model routing, quantization trade-offs, and the dashboards that actually predict spend. Real numbers, real regrets.

Every company has docs; almost nobody has docs people trust. This hands-on workshop walks through building a docs-as-code pipeline — linted Markdown, CI previews, ownership rules, and freshness checks — and the social contracts that keep it alive. You'll leave with a working starter repo and a rollout plan.

Web teams deploy hourly; mobile teams get one shot a week and a review queue. This talk covers running a mobile release train that ships on time every time: feature flag discipline, staged rollouts, crash-gate automation, and what to do when a critical bug ships anyway. Applicable to native and cross-platform teams alike.

Most teams add observability after the first bad outage. This session shows what it looks like to design it in from the start: structured logs as a contract, traces that survive refactors, and dashboards your on-call actually opens. Demo included, pitch kept to the last two minutes.

Your users are global; your primary is in Virginia. This deep dive covers the real options for getting data closer to users — read replicas, logical replication, partitioned writes, and the new generation of distributed Postgres — with the latency numbers and failure modes of each. Includes the migration playbook we used to take a 2TB database multi-region with zero downtime.

Most accessibility work fails because it's bolted on per-feature. Fix it once, in the design system, and every product team inherits it for free. This talk shows the ten highest-leverage component fixes — focus management, touch targets, reduced motion, form errors — with before/after audits from a real design system used by forty teams.

Every system starts with a cron job and ends with a distributed job queue nobody fully understands. This talk maps the evolution honestly: when cron is enough, when to reach for a queue, how to handle retries and idempotency without a PhD, and the observability you need before — not after — jobs start silently failing.

The bugs that hurt most live in the gap between frontend and backend. This talk compares the current approaches to closing it — OpenAPI codegen, tRPC-style inference, and schema-first with runtime validation — using the same feature built three ways. Covers versioning, breaking-change detection in CI, and where each approach falls over at scale.

You don't need a six-node Kafka cluster to move events around — until you do. This talk is a decision guide for streaming architectures at normal-company scale: Postgres-as-a-queue, managed streams, change data capture, and the operational cost curve of each. Featuring the migration we did, the one we skipped, and how to tell which is which.

The most interesting engineering of the next five years won't be a new framework — it will be making the systems we already have boring, predictable, and cheap to run. A closing keynote on error budgets as product strategy, the economics of nines, and why the best incident is the one nobody notices.