Dev Agrawal
Developer Relations Engineer, PowerSync
Wichita, Kansas, United States
Actions
I build and teach how to build awesome fullstack applications. I work as a DevRel Engineer at PowerSync, I'm a core team member of Solid.js, and I make content on YouTube and Twitch. I talk about web development, architecture, reactive programming, home brewing coffee, and heavy metal music.
Links
Badges
Area of Expertise
Topics
When the Frontend Needs Its Own Domain Model
Most frontend architecture collapses the same way: we copy backend entities into the client and start attaching flags like isDirty, isOptimistic, hasConflict, and isSaving. Before long, one Order object is pretending to be a persisted record, a form draft, a sync job, and an error state all at once.
That works for simple CRUD. It breaks down the moment the app needs to be offline, collaborative, or genuinely realtime. At that point the client is dealing with its own business concepts: drafts, edit sessions, pending submissions, conflicts, and freshness guarantees. Those are not just UI details. They are part of the domain of the client.
This session argues that the frontend needs its own model. Rather than mirroring the backend and sprinkling more flags everywhere, we can model client-side objects explicitly, define the commands and events around them, and separate UI state from local domain state from server-authoritative state. The result is a frontend that is easier to reason about, easier to sync, and far less fragile under optimistic updates and collaboration.
Designing Predictable Agentic Workflows
Traditional workflows are built around explicit states, transitions, and rules. Agents are built around probabilistic reasoning and tool use. Trying to combine them forces a hard question: how much autonomy can a business process tolerate before it stops being trustworthy?
This talk looks at agentic workflows as a domain design problem. We’ll explore where deterministic workflow steps still matter, where an LLM can safely operate inside a process, and how policies, approvals, and guardrails keep the overall system predictable even when one participant is not. The goal is to find the right balance between procedural control and agent autonomy, so teams can automate work that was previously too ambiguous or high-touch for traditional workflows.
Designing Agentic UIs: When AI is a Domain Actor
As we integrate LLMs and autonomous agents into our applications, the traditional boundaries of software design are breaking. We used to have human users sending commands to a system. Now, we have AI agents observing the system, communicating with users, and taking autonomous actions.
How do we model this in DDD? Is an AI agent a User? A Domain Service? An external Bounded Context? In this talk, we’ll look at the architectural implications of building "Agentic UIs" and integrating AI into the domain. We’ll explore how to model agent permissions, how to design commands that can be safely issued by non-humans, and how to use the Ubiquitous Language to prompt and constrain LLM behaviors. This is a forward-looking talk about applying rigorous domain modeling principles to the wild west of AI-driven fullstack applications.
Designing Local-First and Collaborative Domains
In their seminal essay, Ink & Switch laid out a vision for "Local-First Software": applications that respond instantly, work offline seamlessly, and allow for real-time collaboration. As an industry, we are rushing to adopt this paradigm to build Figma-like or Linear-like experiences.
But there is a massive architectural collision happening. Traditional Domain-Driven Design assumes the Cloud is the undisputed Single Source of Truth. We keep our clients "thin," relying on backend Aggregate Roots to enforce invariants and validate commands.
Local-first software shatters this model. If the app must work instantly offline and merge collaborative edits later, the local device is no longer just a View—it is a primary node in a distributed system.
How do we design domains where the Source of Truth is concurrent and distributed? In this talk, we’ll map the Local-First ideals to strategic DDD patterns. We will explore how to treat the local device as a fully autonomous Bounded Context, why syncing "Domain Events" is safer than syncing database rows for collaborative features, and how to embrace eventual consistency in the UI without losing data integrity. You'll leave with a framework for building local-first apps that respect both the user's network and your core business rules.
Conflict Resolution as a Domain Concern: Modeling Offline-First Applications
When people talk about offline-first systems, the conversation usually drifts toward sync engines, merge algorithms, and replication protocols. Those things matter, but they hide the real design question: when two valid changes collide, who decides what the system should do?
In many domains, a conflict is not a technical error. It is a business event. Two people reserve the same inventory. A field worker edits stale data. A user completes a task based on information that changed while they were offline. These are domain situations, and treating them as infrastructure problems usually produces bad software.
In this talk I’ll show how we started modeling offline behavior and conflict handling inside the domain instead of around it. We’ll look at how that changes aggregates, commands, invariants, and even the language teams use when discussing “sync issues.” The result is a system that is easier to reason about because it acknowledges that disconnected work and eventual reconciliation are part of the business reality, not edge cases.
Build Your Own Coding Agent: Harnesses, Skills, and Interfaces
Coding agents like Claude Code and Codex can feel magical, but their core architecture is understandable and buildable. In this workshop, you’ll implement a compact coding agent from scratch and learn the engineering decisions that make it useful in practice.
We’ll build the full loop: model orchestration (frontier, open-source, or local), a tool harness for filesystem/terminal actions, lightweight memory, reusable skills, and a simple web interface for interaction and review. Along the way, we’ll focus on practical reliability and safety patterns: constrained execution, structured errors, idempotent actions, and clear approval boundaries for risky operations.
By the end, you’ll leave with a working reference implementation, a clear mental model of how modern coding agents operate, and a concrete path to evolve your prototype into a real developer tool.
Evolution of React Frameworks
React's nature as an unopinionated rendering library—rather than a full framework—means developers must solve many crucial problems themselves. These include bundling setup, state management, data fetching, routing, and server rendering—all essential components in any serious project.
Thankfully, the React ecosystem has evolved to include frameworks that provide opinionated solutions to these challenges. From Create React App and React Static to Remix and Next.js, developers can choose from a rich variety of frameworks.
In this session, we'll explore how React frameworks have evolved alongside ecosystem capabilities and needs. We'll examine how these frameworks define their boundaries, their differing philosophies and implementations, and the innovations emerging from next-generation frameworks.
A Map to the World of Reactivity
“Reactive Programming” is such a wide umbrella of concepts and architectures that two different resources explaining Reactive Programming might seem to contradict each other at times while agreeing with each other otherwise. There’s a lot more to the fundamental idea of Reactivity than what you might get from a single blog post. This talk will attempt to take a higher-level look at Reactivity, describe the anatomy of a Reactive system, and how differences in specific characteristics like push vs pull, sync vs async, and eager vs lazy result in very different architectures and trade-offs. We will also see how these systems are similar or dissimilar to each other using a visual interactive map.
Fine Grained Reactivity - Past, Present, Future
Despite its recent resurgence in the frontend ecosystem, the concept of fine grained reactivity has existed in JavaScript for at least 15 years. But they have never been as prominent as they are today, with every major frontend framework (and most state managers) investing significant effort into making themselves fine grained. There’s even a proposal to add it into the JavaScript language. But how exactly did this happen, and why now?
This session will explore the history of Signals and fine grained reactivity, and how they evolved from a niche approach used by a single library to a unanimously agreed on standard. We will compare fine grained reactivity to competing approaches, discuss trade-offs, and explore some ongoing research into next generation capabilities fueled by signals.
Don’t avoid mutable data, conquer it
This session challenges the dominant trend of purely functional programming and immutable data that has influenced mainstream programming over the last decade. While functional programming brought predictability through pure functions and immutable data, it often comes with performance costs due to the need for data cloning, transformation, and diffing.
The talk explores how to achieve the best of both worlds by using controlled mutable state without sacrificing code clarity. Through practical examples, benchmarks, and real-world comparisons, attendees will learn techniques for encapsulating mutations effectively and discover client-server architectural patterns that can enhance performance while maintaining clean, declarative code.
Build Your Own OpenClaw
If you can’t explain how your assistant works, you can’t safely trust it. In this hands-on workshop, participants build an OpenClaw-style assistant from scratch to understand every critical layer: runtime architecture, state handling, tool execution, and security controls.
We’ll walk through real threat surfaces and implementation tradeoffs, including sandboxing, least-privilege tooling, memory boundaries, and failure recovery. The goal is not feature breadth, but architectural clarity and operational confidence.
You’ll leave with a minimal working system and the ability to reason about its safety, limitations, and trust profile before deployment.
Connecting Agents To The World - MCP, CLI, API, Skills, Computer Use
Coding agents are most useful when they can do reliable work beyond code generation: edit repositories safely, run commands, call services, and complete multi-step tasks. This session focuses on the integration architecture behind coding agents (Claude Code/Codex), with an emphasis on reliability, safety, and maintainability.
We’ll compare practical connectivity patterns: MCP servers, direct REST/GraphQL integrations, sandboxed CLI execution, reusable skills, custom tool implementations, and computer use as a last-resort fallback. Using the same task implemented across multiple patterns, we’ll evaluate tradeoffs in speed, cost, control, and failure modes.
You’ll leave with a concrete framework for choosing the right interface per use case, plus implementation patterns for permission boundaries, idempotent actions, and safe recovery when tools fail.
Fast, Realtime, and Offline-First Apps with Sync Engines
Users expect every click to commit locally in milliseconds, keep working without a network, and reconcile cleanly when connectivity returns. This talk shows how to build that behavior with a sync engine instead of layering ad hoc polling, WebSocket handlers, and fragile optimistic updates onto a traditional client/server app.
We’ll walk through a practical architecture: a local database such as SQLite or IndexedDB as the source of truth on the client, server-side change data capture using logical replication or an append-only change log, and selective replication so each device syncs only the records it is allowed to read. From there, we’ll cover implementation details that usually get hand-waved away: background sync queues, idempotent mutations, version vectors or CRDT-based conflict handling, and designing UI states around eventual consistency.
You’ll leave with concrete patterns for shipping collaborative, offline-capable features incrementally, plus a migration path for introducing sync into an existing app without a full rewrite.
Retrieval Augmented Generation - Simpler Than It Sounds
RAG unlocks many of the most useful AI product experiences by grounding model output in real context: docs, tickets, codebases, and domain data. Most teams can build a demo quickly. The challenge is making it reliable, fast, and maintainable in production.
This session breaks RAG into practical architectural choices: retrieval strategy (keyword, vector, hybrid, graph), indexing and freshness, ranking, prompt assembly, and evaluation. We’ll also cover where teams get stuck with related patterns like memory and agentic RAG, and how to decide when they actually help versus add complexity.
You’ll leave with a decision framework for choosing the right RAG approach per use case, plus concrete implementation patterns to improve answer quality, reduce hallucinations, and keep latency and cost under control.
The AI-Friendly Codebase: Context Engineering for Fun and Profit
You tried the latest coding model on your repo and got low-quality changes you’d never merge. The problem is often not the model, it’s the codebase context.
Not every repository is friendly to agentic engineers, just like not every repository is friendly to humans. This session covers practical context engineering techniques to make AI output more reliable: clearer module boundaries, better naming, task-oriented documentation, decision records, and machine-readable conventions that reduce ambiguity.
We’ll walk through before/after examples showing how small structural changes improve edit quality, reduce unsafe cross-cutting diffs, and make code review faster. By the end, you’ll leave with a concrete checklist to audit your own codebase and incrementally optimize it for high-quality AI collaboration.
Understanding Web Application Architecture
Web applications have gone through many evolutions over the last two decades. Web development is a relatively young industry, yet the expectations have grown rapidly putting all sorts of constraints on our tools and workflows. Because of the constant churn, it’s difficult to keep up with all the changes and evolutions in how we approach building web applications. Starting with server-centric models, swinging all the way to fully client-side SPAs, to revisiting server-first MPAs, it seems like the ecosystem has been all over the place. At the same time, platform limitations and tooling complexity has led to developers seeking simpler solutions to more relevant problems.
This session attempts to explain the various approaches and architectures of web applications by going back to fundamentals. We will see the issues with server-centric models that led to client-first development, issues with client-first model that have led the push back to server-centric models, and how both architectures have learnt from each other and addressed their own limitations. You will walk away with a solid understanding of web architecture, and some ideas on how to improve the architecture of your own web applications for better user and developer experience.
What Comes After The Virtual DOM? Evolution Of Frontend Development
Frontend architecture is shifting from coarse component re-renders to fine-grained updates, and that shift is changing how we build for performance, streaming, and hydration. This session explains what comes after the virtual DOM and why it matters in real apps.
We’ll compare the implementation models used across today’s ecosystem, from signal-style fine-grained reactivity to resumability, partial hydration, and async rendering patterns. Rather than focusing on hype, we will example technical and mechanical advancements: update granularity, memory behavior, hydration cost, debugging complexity, and developer ergonomics.
Using concrete examples, you’ll learn when these newer models outperform traditional VDOM approaches, and how they result in logic that is simpler and easier to reason about.
Zero Pain Frontend to Fullstack in Minutes with Open Source
How silly is it that in 2023, with the huge diversity of tooling out there for frontend devs, half of our productive coding time is still spent on continuous error handling?! From code duplication, to typing errors, routing, validation, authentication…the list goes on.
As a NodeJS developer, we want to be able to keep our code DRY –– literally just write once, and reuse, by maintaining our code in a single source of truth. Sounds too good to be true? It is possible.
In this live coding demo we’ll walk you through how to take a common NodeJS/Express/Fastify stack and convert it into a fullstack app in minutes using open source tooling and frameworks all fullstack developers should know about.
Meet Your New BFF: Backend to Frontend without the Duct Tape
Even with all of the incredible frameworks available today vs. a decade ago (or even two––for devs who have been around as long as I have), it still feels like much of our work as fullstack developers is still repetitive, and held together by duct tape code we shouldn’t be writing.
This is because we write a lot of duplicate and boilerplate code for everyday things such as simple database CRUD, data validation, authorization, and data-type conversions, but the majority of these tasks haven’t advanced at the pace of modern web architecture.
In this live coding session we'll turn a front-end app into a fullstack app with code that is easy to write, follow &, most importantly maintain, with end-to-end typesafety (say no to GraphQL!), consistent and encapsulated validations, live querying, access control, secured APIs, you get the idea.
You’ll come away from this session able to build apps for modern web architecture while still maintaining our code DRY and increase productivity.
Building simple and delightful web apps with SolidStart
Building decent full-stack web applications seems way too hard these days. SolidStart is a futuristic web framework based on Solid.js that attempts to provide powerful capabilities and efficiency while staying minimal and unopinionated. In this workshop will give you an overview of how SolidStart makes it easy to build complicated and efficient web applications through its array of capabilities like
- Fine grained rendering
- Non blocking data fetching
- Isomorphic rendering
- File system routing
- Annotated server functions
- Single flight mutations
- Optimistic UI updates
Build an end to end Next JS app with Next auth, postgres realtime functionality
With the new Next JS app router functionality, a lot have changed with building next js applications.
In this hands-on workshop we'll build a full stack CRUD application that will use Postgres as a database, Next Auth for authorization, and even ably for real time functionality.
It'll include:
* Server side sorting, paging and filtering
* Front end query language
* Data validation on both frontend and backend
* Authentication using Next Auth
* Authorization of api and front end functionality.
* Deployment to a node js cloud and a serverless cloud
Streams, not Waterfalls - Improving Page Load and Core Web Vitals
Single-page apps unlock instant user interactions and highly dynamic user experiences, but as applications get more complex, the price is paid in terms of performance. We either end up with cascading client-server fetches for code and data, or with obscenely large JavaScript bundles to bring in caching solutions. This talk will explore how Streaming architecture is helping applications load much faster by eliminating client-server waterfalls, significantly improving the core web vitals and user experience, and how React is bringing the benefits of Streaming to its declarative component model.
Meet The Web Framework From The Future
What would you envision your futuristic web framework to be like? What kind of properties would it have, and what would it enable for you?
For me, the future of web frameworks should be performant by default, developer friendly, minimal but flexible to business needs, and use both the client and the server runtimes to their maximum potential.
It’s a tough criteria, and most frameworks fail to meet a lot of these requirements. However, Solid Start is a framework that checks all of these boxes, aims for a very high ceiling, and has already inspired many popular frameworks to add similar features.
Let’s take a look at the shape of frameworks to come in this session by building a sample application with Solid Start, witness its incredible UX and DX capabilities, and how it compares to other frameworks like Next.js and Astro.
Deploying Stateful Realtime Services To The Edge
Modern serverless development has unlocked a new level of developer velocity and made it easier for teams of any size to ship software at any scale. Platforms like AWS Lambda, Fargate, DynamoDB, and EventBridge offer primitives to build asynchronous business applications that can serve millions of users reliably. However, there is an entire class of multiplayer and realtime applications that cannot be served by stateless architectures, and building such applications requires going all the way back to manual sharding, load balancer, state synchronization, smart routing, and so on.
This talk will explore how we can build stateful services without giving up the ease and speed of serverless technology, and deploy them closest to the users. Using a Cloudflare technology called Durable Objects, we will build a live multiplayer application where users can interact with each other and play a game together in real time. We will explore the tradeoffs of this stateful serverless paradigm, and how it can be incrementally adopted to enhance the user experience of any application.
Building Asynchronous UIs Without The Hassle
The days of static HTML documents are long gone. Modern user interfaces are dynamic, interactive, and complex. Most of this complexity comes from having to manage and represent concurrent asynchronous processes like requests to the server, timeouts and retries, background processing, native/browser apis, and so on. Frontend frameworks like React are incredibly helpful at constructing a synchronous UI representation of the application state, but force us to orchestrate user events with async processes ourselves. This approach is riddled with issues like race conditions, inconsistent state, UI tearing or flickering, spinner hell, etc.
These issues are being addressed by frontend frameworks like React and Solid with new features that eliminate all the asynchronous orchestration and give us consistent UIs by default. This session will explore some of these features, and how they remove a lot of the complexity of building dynamic and asynchronous frontends.
Build your own React Metaframework
This session will explore what exactly a metaframework like Next.js or Remix is, what responsibilities they take on, and how they differ from each other, all by building a custom metaframework live on stage.
CodeMash 2025 Sessionize Event
The Commit Your Code Conference Sessionize Event
Dev Innovation Summit 2024 Sessionize Event
React Rally 2024 Sessionize Event
Stir Trek 2024 Sessionize Event
CodeMash 2024 Sessionize Event
JavaScript & Friends 2023 Sessionize Event
Dev Agrawal
Developer Relations Engineer, PowerSync
Wichita, Kansas, United States
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top