AGENDA
SiT BACK AND RELAX,
WE carefully DESIGN THE day FOR YOU!
At dotConferences, we've been designing conferences agendas since 2012 with 45+ conferences held.
We heard our attendees feedback: you want dense talks, an energetic rhythm, the ability to network and build new connections, and an overall fun and knowledge-packed day!
That is why:
-
The longest talks are 20 minutes. Yes, even the most deep tech ones.
-
Shortest lightning talks are after lunch.
-
You have breaks that are not too short, so you have time to network and see our partners. 30mn minimum and multiple breaks during the day.
-
You can ask your questions to speakers live during interactive Q&A.
-
If your question wasn't selected, you can talk with speakers in the Speaker lounge after their talk.
-
Coming alone to a conference can be daunting, so we made a giant networking game to help break the ice throughout the day.
-
There is a single track, so you're not missing anything.
agenda
(*Might be subject of subtle last-minute changes)
⚡ are for 10-min lightning talks
9.00 am
Doors open 🚪
9.00 am - 9.30 AM
Welcome coffee 🥐
.png){kind=small}
11.05 am - 11.40 AM
Morning break ☕
12.50 Pm - 2.10 PM
Lunch break 🥪
3.40 Pm - 4.15 PM
Afternoon break 🍰
5.45 Pm - 7.15 PM
Happy Hour! 🍹
Jad Joubran
"The (Abundant) State of the Web"
The web platform is evolving faster than ever—and where we once waited years for broad feature support, we're now seeing capabilities land across browsers at an unprecedented pace.
At the same time, AI is changing how we build for the web.
Boilerplate is disappearing. APIs are easier to navigate. Entire features can be scaffolded in seconds. But as building gets easier, expectations get higher—and what it means to be a "good" developer is shifting.
In this talk, we'll explore where the web stands today, what's finally become reliable, and how modern capabilities are unlocking new possibilities.
We'll also look at how AI is reshaping the development process and which skills actually matter in this new, more abundant era of the web.
Nico Martin
"Boring but Effective: WebAI That Ships"
Everyone's talking about generative AI. But machine learning is so much more than chatbots... and a surprising amount of it runs directly in the browser, on ordinary consumer hardware. Text embeddings for semantic search, real-time speech recognition, image tasks like background removal: small open models, often just a few megabytes, powered by tools like Transformers.js and WebGPU. No cloud subscription, no API key, no gigabyte downloads. In this talk, we'll explore the tasks that already work on the hardware your users own. Live, fully offline, and ready for production. Effective? Absolutely. Boring? Let's find out.
Karen Li
"What You’re Really Trusting When You Run npm install"
Every day, developers run npm install without thinking twice about what happens next. That single command pulls in hundreds of packages, many of which we have never seen or reviewed. In practice, installing dependencies is an act of trust in a vast and mostly invisible network of maintainers. This talk explores what we are actually trusting when we build modern JavaScript applications. We will break down how dependencies are resolved and how code flows from publishers to users. From there, we will examine how that trust can fail and why a single compromised package can have ecosystem-wide impact. We will look at how these failures propagate through dependency graphs in ways that are difficult to detect. The talk will also trace these issues back to the publishing side and the role of credentials in maintaining trust. Emerging approaches such as identity-based publishing and improved provenance will be discussed as ways to strengthen the system. By the end, you will see npm install not as a simple command, but as a gateway into a complex trust network that shapes the JavaScript ecosystem.
Matheus Albuquerque
"Web Performance APIs That You (Probably) Never Knew Existed"
Responsiveness to user interaction is crucial for modern web apps, and we’ve all heard about many fantastic tools for measuring and optimizing performance.
However, we no longer have to rely entirely on pre-built dashboards to understand performance. Browsers already expose a rich set of native performance APIs that let us go deeper.
In this talk, we’ll explore lesser-known platform primitives for measuring responsiveness and diagnosing bottlenecks. We'll cover everything from observers and timing APIs to scheduling primitives, resource hints, and navigation improvements like View Transitions.
Be ready to turn your browser into a performance toolkit and build performance metrics that reflect what your users really care about.
maximiliano firtman
"Unlocking Client-Side AI in Your Web App"
You don’t need a cloud subscription or backend infrastructure to bring powerful AI features into your web app. Thanks to modern browser APIs and local model support, it’s now possible to run generative AI — including text, vision, and speech — entirely on the client side.
In this session, you’ll learn how to unlock AI capabilities in the browser using built-in AI APIs, WebNN, WebGPU, and WebAssembly. We’ll explore how on-device models, such as Gemini Nano in Chrome, and open-source models enable local inference for language, vision, and audio: privately, offline, and without recurring cloud costs.
We’ll cover architecture patterns, browser and device capabilities, and live demos, including how to detect support and decide when to use built-in models, your own client-side models, or a cloud fallback.
If you’re building for the Web, this talk shows how to add real AI to your web app: locally, privately, and using technologies available in the browser today.
Thorsten Seyschab
"Promise You'll Know It? The async JavaScript Quiz"
Ever questioned if your JavaScript foundation stands as solid as you think? Between the daily grind of framework logic and build pipelines lies a language full of historic oddities, coercion chaos, and strict mode surprises that often go unnoticed.
This session turns the conference hall into a live game show. You won't just sit and listen - you will join a real-time interactive quiz using your smartphone. We will traverse the weird parts of type coercion, challenge your mental model of the event loop, and spot build configuration errors within the modern ecosystem. You will vote on answers, solve syntax conundrums, and uncover facts about the specifications you likely missed.
Come for the fun, stay for the challenge. You will leave with new insights into how the engine really works and perhaps the bragging rights of being the top expert in the room.
Nikolay Rodionov
"Building MCP Apps with All the Comfort of Modern TypeScript DevX"
Building AI-powered apps shouldn't mean giving up the developer experience you expect from modern tooling. Yet, the current proposed way of building app relies on pre-built assets that need to be cache invalidated. This is fine for production, not for development.
In order to cope for the missing modern dev environment, Skybridge, an open-source fullstack TypeScript framework, ships feature aimed at improving builders life.
In this talk, you'll learn how to iterate fast on your app developpement cycle using Skybridge's local emulator and hot module reload, test changes without redeploying
You'll also discovery the provided typesafety tooling going from tool responses to widget props, catch errors at compile time instead of production
We'll walk through a live dev session: starting an app, making changes with HMR, and catching type errors before they ship.
Guillaume Moigneu
"TypeScript was built for agent factories (it just didn’t know it yet)"
Running agents at scale is a manufacturing problem. A factory needs a production line with quality gates, so output arrives inspected, not hopeful.
TypeScript already has the line. From intent to PR, the work passes through the densest set of machine-checkable gates in software: types as contracts, schemas as runtime guarantees, unit and end-to-end tests that prove the agent built the right thing, not just a plausible one. None of it was designed for agents. All of it is exactly what they need.
Those gates, and the artifacts they leave behind, are trust loops. They let a team inherit agent work the way they would a new hire’s. That is how you industrialize trust, and how an assistant becomes a teammate.
TypeScript was built for this. It just didn’t know it yet.
Gabor Csomak
"Microfrontends done right"
Microfrontends are extremely popuplar right now, but here’s the uncomfortable truth: most of us are doing them wrong. The majority of materials, blog posts, and tutorials frame microfrontends as a purely technical solution: split your UI into smaller chunks, add some tooling magic, and voilà—problem solved. Except… it isn’t.
Microfrontends are not about making your fragments smaller; they’re about making your teams faster. They’re an organizational strategy disguised as an architectural pattern. When misapplied, they add overhead, slow you down, and leave you wondering why everything feels harder instead of easier.
I've been developing microfrontends since 2012, and I'll share all my learnings with you. It’s time to stop slicing for the sake of slicing—and start using microfrontends the way they were meant to be used, to accelerate development.
Harshil Agrawal
"Beyond the Chatbot: Generative UI and the Execution Trust Problem"
Chatbots have become the default interface for AI, but forcing every interaction through a text bubble sells the technology short. Users don't want to chat with their data, they want to interact with it through dashboards that build themselves, forms that adapt to their intent, and UIs that evolve in real-time. Generative UI makes this possible: instead of returning text, an LLM returns React components tailored to each user's specific needs. The problem is execution trust — running AI-generated code in your app is a security nightmare. Traditional sandboxing approaches like iframes, Web Workers, or VM2 force you to choose between performance and isolation, and neither option is good enough for a production React app. In this talk, I'll show you how V8 isolates at the edge solve both problems simultaneously, executing AI-generated TypeScript in milliseconds while keeping the blast radius contained. You'll see a live demo of a React application that dynamically generates and securely renders components based on user intent, with no chat bubble in sight. Beyond the demo, you'll walk away with a concrete blueprint for architecting React apps that support runtime component injection safely. I'll share the security implications I encountered shipping this in production and the patterns I developed to mitigate them using ephemeral sandboxes. Whether you're building AI-powered products today or preparing for the post-chatbot era, you'll leave with practical patterns you can apply immediately.
Bart Waardenburg
"JavaScript tooling has a blind spot: codebase-wide questions"
AI can write plausible diffs quickly, but in large TypeScript and JavaScript repos the real failure mode usually is not syntax or types. It is missing system context. The agent does not know which exports are already dead, which modules sit in risky cycles, where duplication already exists, or which architectural boundaries should never be crossed.
In this talk I will show why AI-assisted development needs a deterministic codebase truth layer: project-wide analysis that both humans and agents can query before changes land. I will walk through the kinds of issues that appear in real JS/TS repos when AI speeds up code creation, how graph-based analysis catches them, and where runtime evidence changes “this looks safe” into “you can delete this with confidence.”
You will leave with a practical model for using AI faster without letting your codebase quietly drift into dead code, duplication, and review fatigue.
Key takeaways
- Why AI-assisted coding creates codebase-level problems that file-level tools miss
- How to add deterministic codebase analysis into PR review and CI
- When static analysis is enough and when runtime evidence should drive the decision
These are the reasons I build Fallow. Featured on the Syntax.fm “How to Fix Vibe Coding,” episode. They call it “the number one tool I think that people aren’t using” for this class of AI-driven code-quality problems.
Vishnudhasan Govindarajan
"Your Lighthouse Score Doesn’t Matter on 3G"
Your Lighthouse score is not the truth. Most tools reflect ideal lab setups, not real-world usage. This talk shows how modern JavaScript architectures are failing billions of users. Learn how to rebuild for the actual performance landscape where 3G networks and $100 devices are still the norm.
Many teams believe their apps are fast because their tools say so. But synthetic metrics often miss the slow pain of real users. In countries across Asia, Africa, and South America, a 2MB bundle and unoptimized hydration are not minor annoyances they are barriers to access. This talk breaks down the systemic bias toward high-end testing environments and how that has shaped the web we have today.
You will learn how to accurately simulate slow devices and poor networks, how to audit for runtime bottlenecks on low-tier Android hardware, and how to prioritize critical content over framework overhead. We will look at the cost of common design patterns like client-side routing and heavy JS hydration, and how to reclaim speed through vanilla code, critical CSS, and server-led rendering models that actually degrade gracefully.
Devlin Duldulao
"A 50-year accident: how JavaScript got Date, and why Temporal exists"
Timezones. Leap years. Daylight saving. Lunar calendars. Nanoseconds. Mutability. What started as "I just need today's date" somehow became one of the most treacherous corners of web development. This talk is a guided tour through why date and time handling is genuinely, deeply hard — and why JavaScript's Date object makes it harder than it needs to be. We'll then meet Temporal, JS's long-awaited replacement, and discover how its carefully separated types (Instant, PlainDateTime, ZonedDateTime, Duration...) turn a minefield into a map.
Lea Verou
"No-build: pipe dream, or near future?"
""
Almost every JS dev uses bundlers. Few actually like it.
The mavericks who try to go no-build learn the hard way why it's still fringe.
Are we stuck with bundlers forever, or is there light at the end of the tunnel? (And is that light an oncoming train?)
This talk takes a pragmatic look at what drives bundler usage, how well the web platform addresses those needs today and in the near future, what’s still missing for no-build architectures to become viable, and whether AI changes the equation.
A SPECIAL DOTJS recipe
not just talks, BUT CONVERSATIONS
Ever been to an event where you just sit and listen all day, without a chance to ask questions or connect with interesting people? Frustrating, right?
At dotJS, we do things differently. Here, you get direct access to speakers through 1:1 conversations, exclusive entry to the speaker lounge, and live Q&As after every talk. Don’t just listen, engage, exchange ideas, and meet the brightest technical minds in the JS ecosystem!
A TECH TEAM EXPERIENCE
Most conferences cater to just one profession: you’re either in the world of development or the world of engineering.
At dotJS, we bring them together. We focus on the teams that build: front-end engineers, back-end and full stack engineers, web developers, software developers, CTOs, Heads of Web, engineering managers, and more. Many companies even turn it into a team-building experience.
Come as a team, leave with projects!
SAVE TIME, in premium settings
If you’re after efficience, you’re probably tired of wasting your time with sponsored content and endless non-valuable sessions. And you’re right!
At dotJS, our talks are never for sale. Period. Every session is carefully curated by an independent Editorial Board of top researchers and engineering leaders. Plus, each talk is rehearsed and distilled into just 20 minutes to maximize value.
And because great ideas flourish in the right environment, we ensure premium conditions: access, food, and experience are our no-brainers.