░██████╗░█████╗░██╗░░██╗░██████╗██╗░░██╗░█████╗░███╗░░░███╗
██╔════╝██╔══██╗██║░██╔╝██╔════╝██║░░██║██╔══██╗████╗░████║
╚█████╗░███████║█████═╝░╚█████╗░███████║███████║██╔████╔██║
░╚═══██╗██╔══██║██╔═██╗░░╚═══██╗██╔══██║██╔══██║██║╚██╔╝██║
██████╔╝██║░░██║██║░╚██╗██████╔╝██║░░██║██║░░██║██║░╚═╝░██║
╚═════╝░╚═╝░░╚═╝╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝╚═╝░░╚═╝╚═╝░░░░╚═╝
I work across four layers most engineers only touch one or two of — web, React Native, SDKs, and the backend underneath them — and I've shipped in all of them to real, live users, not just a staging build.
Day to day that means moving between a Next.js dashboard that needs to feel instant, a React Native app that has to keep working when the network doesn't, an Express/MongoDB API tying it all together, and the SDK layer that quietly holds everything else in sync. I like the unglamorous parts of that stack the most — sync logic, retry handling, the edge case that only shows up in production.
What I actually spend my time on:
- Owning a feature end-to-end — Node/Express/MongoDB on the backend through to React or React Native on the frontend — when a project needs one person across the stack
- Making offline-first mobile apps survive bad networks without losing user data
- Building SDKs that other developers can integrate without reading my source code first
- Wiring AI into product flows in a way that earns its place, not as a gimmick
- Writing frontend architecture that the next engineer (or future me) won't curse at
| Layer | Technologies |
|---|---|
| Web | React · Next.js · TypeScript · Tailwind CSS |
| Mobile | React Native · Android · iOS · Expo |
| Backend | Node.js · Express · MongoDB · REST API design |
| SDK | SDK architecture · Versioning · Consumer-facing API design |
| State | Zustand · Redux Toolkit · TanStack Query |
| Data / Offline | WatermelonDB · IndexedDB · LocalStorage |
| API | Auth Flows · Token Management · Pagination |
| AI | OpenAI SDK · Tool Calling · Structured Outputs · LangGraph |
|
I build the parts of a web app that are boring to describe and hard to get right — component architecture that survives a year of feature requests, an Express/MongoDB API underneath it, and performance that's measured, not assumed. In practice:
|
React Native apps that keep functioning when connectivity doesn't — because for most users, "offline" isn't an edge case, it's Tuesday. In practice:
|
|
Building the layer other developers integrate against — where a confusing API or an undocumented edge case becomes someone else's production bug. In practice:
|
AI features that solve an actual product problem — not a chatbot bolted on for the sake of having one. In practice:
|
mindmap
root((How I
Think About Code))
Architecture
Clarity over cleverness
Build for the next dev
Systems, not one-off features
Execution
Measure before optimizing
No shortcuts in the data layer
Test the paths users actually hit
Craft
Docs aren't optional
Reusable over repeated
Own the boring parts too
Product
Offline is normal, not an edge case
Performance is UX
AI only where it earns its place
status: "Building and shipping — day job + side projects"
working_on:
- React Native architecture patterns that scale past one app
- Offline-first sync with real conflict resolution, not just retry loops
- SDK design that other developers don't have to fight
- AI-assisted product workflows
learning:
- LangGraph and agentic workflow design
- Frontend system design at scale
- Modern AI infrastructure patterns
open_to:
- Frontend Engineer · React Developer · React Native Developer
- Product Engineer · Software Engineer
- Remote · Contract · Full-TimeOpen to talking through interesting problems, architecture decisions, or opportunities — reach out if any of the above sounds relevant to what you're building.
"Good software is built twice — first in architecture, then in code."