Six editor surfaces, one renderer.
The builder's six view types and the generated live app now share one renderer with per-node updates, so previews match production and large screens stay fast.
Full-stack engineer in Bengaluru
HirenLimbasiya
Software Developer
Senior Developer
Now
Tech Lead
At Zino Technologies since January 2023
A platform that builds business apps, without code.
Companies assemble their own forms, approval workflows, dashboards and AI agents from settings. I lead the visual builder, the runtime that serves the apps it generates, and the AI underneath.
- 10+
- Go services behind the platform
- Under 15 min
- from a prompt to a deployed app
- Zero
- downtime when a workflow is published
How the platform is put together
- React 19 frontends
- Visual app builder
- The live app it generates
- Go services (10+)
- Builder and publishing
- Workflow engine
- AI and agents
- Data and messaging
- PostgreSQL for app and report data
- NATS JetStream for background jobs and agent tasks
Top to bottom: what users touch, the services behind it, and where data and jobs live.
Four calls I made, and why.
type ProviderCodec interface {
EncodeRequest(req ChatRequest) ([]byte, error)
DecodeResponse(raw []byte) (ChatResponse, error)
Endpoint(model string) string
AuthHeader(key string) (string, string)
}Every model behind one gateway.
Claude, Gemini and OpenAI sit behind one internal API with cost tracking, so any service swaps models without a code change.
Read the gateway noteDrag and drop with no library.
Nesting, snapping and resizing run on raw DOM events over a normalized model, so every save round-trips exactly.
Read the drag-and-drop noteRuns stay on the version they started.
In-flight runs are pinned to their workflow version, so editing a live workflow never breaks instances still executing, and publishing needs no downtime.
Full-stack tech lead on a no-code platform where companies build their own business apps (forms, approvals, dashboards, and AI agents) without writing code. I own the architecture across frontend, backend (10+ services), and AI.
- Shipped the AI creation workflow that takes a prompt and deploys a working app.
- Wrote an Excel-like formula language that evaluates identically in JavaScript and Go.
- Built a spreadsheet-style data grid: 12 cell types, keyboard navigation, copy and paste.
- Created the Master Data Management pipeline builder (API integrations, ETL transforms, webhooks) and the runtime that executes its config.
Stack
- React 19
- TypeScript
- Go
- PostgreSQL
- NATS
- Kafka
- LLM and RAG
All 18 pieces of work at Zino9 frontend and 9 backend, one line each on what I built and how.Show allHide
Frontend
- Visual app builder
- Built the drag-and-drop screen builder from scratch: nesting, snapping, and resizing on raw DOM events with no library, over a normalized model so every save round-trips exactly.
- AI agent builder
- Shipped the agent-authoring UI and its tool-calling loop. Users set an agent's instructions, tools, and knowledge, then test it against the live model in place.
- Visual data-pipeline builder
- Built the editor for the platform's data-management tool. Users chain API calls, transforms, validation, and webhooks, and the same config executes at runtime.
- Unified rendering engine
- Collapsed the builder's six view types and the generated live app onto one renderer with per-node updates, so previews match production and large screens stay fast.
- Form rules engine
- Drove conditional show/hide and auto-calculation off an event queue with a cycle guard, so field rules resolve instantly and never loop.
- State architecture
- Split state across the builder's screens, workflows, and forms with Redux Toolkit, scoped Contexts, and custom hooks, partitioned by update frequency so editing one module doesn't re-render the rest.
- Reusable custom hooks
- Packaged the builder's trickier logic into hooks, including a deep config-diff hook that powers the unsaved-changes indicators and confirm-before-leave prompts.
- Internal component packages
- Published the form renderer, charts, and data tables as internal NPM packages now used by other teams across the platform.
- Large-scale performance
- Kept data tables and dashboards smooth at 10k+ rows with virtualization, memoization, lazy loading, debouncing, and throttling.
Backend
- AI agent runtime
- Built the execution engine behind the agent builder: multi-turn tool calling, document retrieval (RAG), sub-agents, and human-in-the-loop pauses.
- Conversational app generation
- Built the generator that turns an interactive Q&A with Claude into a working app and its workflows, then deploys it, and answers questions about the resulting data.
- LLM gateway
- Put every model provider behind one internal API with cost tracking, so any service swaps models without a code change.
- Zero-downtime versioning
- Version-pinned in-flight runs so editing a live workflow never breaks instances still executing on the previous version.
- Runtime data pipelines
- Built the ETL runtime (API integrations, transforms, and webhook execution) driven by the config the visual pipeline builder produces.
- Scheduled jobs
- Ran background cron that reconciles the fast report tables against source data and clears stale runs, acting as an auditable system user.
- Flexible query layer
- Hand-rolled composable CRUD over raw SQL and no ORM, covering filters, sorting, and cursor pagination across 30+ resource types.
- RBAC and tenant isolation
- Built role-based access across the platform and re-resolve each tenant's permissions from the database on every request rather than trusting the token.
- Concurrency in Go
- Drove the workflow engine on goroutines, channels, and worker pools, with a lock-free per-run buffer so a multi-step automation commits all-or-nothing.
Education
Full Stack Web Development (MERN)
Newton School, Bengaluru
Mar 2022 to Dec 2022
800+ hour full-stack apprenticeship: React, Node.js, MongoDB
Bachelor of Engineering
S.S.A.S.I.T, Surat
2016 to 2020
Tools
- Frontend
- React 19, Next.js, TypeScript, React Native (Expo), Redux Toolkit, Tailwind CSS
- Backend
- Go (Golang), Fiber, Node.js, WebSocket, JWT
- Data and messaging
- PostgreSQL, MongoDB, MySQL, NATS JetStream, Kafka, Raw SQL (no ORM)
- AI and LLM
- Claude, Gemini, OpenAI, LLM gateway, RAG, AI agents, MCP
- Systems
- Multi-tenancy, RBAC, State machines, Performance tuning, Docker, Vercel, Netlify, Internal component packages
Other systems I’ve built
All four repositories are private, so there is no public source to link.
Field sales platform
A B2B field-sales platform for an industrial-equipment company: orders, CRM, daily visit planning, GPS attendance, leave/HR, and analytics across 8 roles. One Go REST API serves both a React 19 web dashboard and a React Native (Expo) mobile app.
Notable: OTP-based passwordless auth with manager-approval gating, and background GPS tracking for field reps.
- Go
- Fiber
- PostgreSQL
- React 19
- React Native
- Expo
Factory ticket management
A backend for factory service requests that flow through a strict, role-based state machine (shop floor → engineers → maintenance head → factory head) with dual-approval support requests, factory-scoped access, and file uploads.
Notable: An immutable transition table with a state-history audit, plus an hourly job that auto-closes stale tickets as an auditable system user.
- Go
- Fiber
- PostgreSQL
- State machine
- RBAC
- Cron
Community forum
A real-time chat and discussion platform with live rooms and threaded conversations, on a modular Go backend with topic management.
Notable: One Go WebSocket hub broadcasts rooms, threads and reactions to every connected client.
- Go
- Fiber
- Next.js
- MongoDB
- WebSocket
Clinical trial dashboard
A full-stack MERN dashboard that turns raw clinical-trial data into interactive analytics: metrics, geographic and demographic charts, full-text facility search, and a paginated officials directory.
Notable: All analytics run on MongoDB aggregation pipelines over an index-tuned schema, behind a hardened Express API with rate limiting, Helmet, and compression.
- React 19
- Redux Toolkit
- Node.js
- Express
- MongoDB
- Recharts
Technical notes, with the code.
- AI and LLMBuilding a Provider-Agnostic LLM GatewayOne gateway for Claude, Gemini and OpenAI: one request format, a pluggable codec layer, central cost tracking, and model swaps without a redeploy.
- AI and LLMDesigning AI Agents that Use ToolsWhat turns an API call into an agent: the tool-calling loop, the right tools and context, grounding answers with retrieval, and pausing for human approval.
- FrontendVirtualizing Large React Tables and Taming Re-Render CascadesWhy a data table dies at 10,000 rows, how virtualization fixes it, and the three habits that cause re-render cascades, plus when memoization is wrong.
- FrontendBuilding Drag-and-Drop From Scratch with Pointer EventsNested containers, snap-to-grid and multi-select resize: the pointer-event loop behind a visual builder, and why drag state belongs in a ref.
- FrontendFive Kinds of React State (and the Right Tool for Each)URL, server, form, UI and global state are five different problems. Which tool each wants, when Redux Toolkit earns its place, and when a hook beats both.
- BackendGo + Fiber Patterns: Query Pipelines and Graceful ShutdownA filter-validate-sort-paginate pipeline that serves 30+ resource types without duplicated query code, plus SIGTERM handling so deploys drop no requests.
- BackendUsing PostgreSQL and MongoDB in the Same ProjectNot SQL versus NoSQL, but both: where Postgres earns relational data and transactions, where Mongo aggregation wins for analytics, and how to split them.
- BackendWhere to Store a JWT (and Why Not localStorage)localStorage is one XSS away from account takeover. Access tokens in memory, refresh tokens in httpOnly cookies, and permission checks in middleware.
- BackendScaling Go WebSockets Across Servers with Redis Pub/SubOne WebSocket server works until you add a second. The Go hub pattern for connections and rooms, and the Redis Pub/Sub bridge that scales it horizontally.
- DevOpsMulti-Stage Docker Builds: 1.2 GB to 15 MBShipping build tools to production is the default, and it is wrong. How multi-stage builds cut a Go API image by 99%, and a reproducible Compose dev setup.