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
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