I'm a full-stack engineer at Halma plc, building the whole path: PostgreSQL schemas and NestJS services at the back, Kafka and Redis in the middle, Angular and Next.js dashboards at the front, and Docker/Kubernetes underneath it all.

The half I'm most interested in right now is AI in the engineering loop. I've built a custom LLM agent harness and n8n automation that my team uses daily, and I work with RAG, vector search and agentic frameworks like BMAD and GSD. Not models — systems: the orchestration, the tool layer, the retrieval, and the glue that makes an agent useful instead of impressive.

The other half of my work is hardware-facing. I'm the primary developer on SyncIT, the application that manages Sensit's gas-detection instruments over BLE, Wi-Fi, LAN and serial, on Android, iOS and Windows from one Flutter codebase.

I also mentor juniors and colleagues on the codebase, and work with the project manager and engineering manager in Wrike on task breakdown, sizing and distribution.

I studied Computer Science at SVNIT Surat, graduating in 2024 ranked 5th of 135 with a 9.19 CGPA.

Halma plc   2024 – present

A platform that ingests high-volume sensor data and puts it in front of customers as live dashboards. I work across the whole stack on it.

Backend

• Engineered the REST API surface and backend services on NestJS.
• Built the ingestion path with Apache Kafka event streaming, Redis caching and BullMQ job queues, so high-volume sensor data lands reliably instead of dropping under burst load.
• Designed for scale and fault tolerance — the data arrives faster than any single service wants to handle.

Frontend

• Built real-time HighCharts visualizations on Angular, including interactive wind-rose plots and correction dashboards, so customers can read live field data at a glance.

Infrastructure

• Containerized services with Docker, deployed on Kubernetes, and wired up CI/CD pipelines for scalable, fault-tolerant releases.

Performance

• Refactored data-intensive modules and optimized LiteDB queries in a legacy UWP desktop app — reports and grids load up to 75% faster.

Sensit Technologies · Halma India   2025 – present   Android · iOS · Windows

Sensit has made gas-detection instruments for utilities, firefighters and hazmat teams for over 40 years. SyncIT is its next-generation instrument management platform. It retired 5 older Sensit apps, with all their functions consolidated into SyncIT Lite and SyncIT Plus.

I'm the primary developer on it, working with a 25–30 person team across software, firmware, hardware, QA, project management and marketing, split between Ahmedabad, Valparaiso (Indiana) and Bolzano (Italy).

What I did

• Took SyncIT from a proof of concept to a production-ready MVP, and have kept evolving it since through new features, architectural improvements and client-driven changes.
• Retired 5 older apps and moved all their functions into SyncIT Lite and Plus.
• Structured it as a Melos monorepo with two product variants on a shared core package and a dedicated log-parsing SDK.
• Built the device communication modules — BLE for gas-detection instruments, and Wi-Fi, LAN and serial for calibration stations — covering log download, parsing, visualization, firmware update workflows and multi-format export.
• Suggested and built a settings application for three instruments, with an automated BLE update flow across 50 settings. Working with the firmware team, this cut manual production effort by about 99%.
• Performance: improved app performance by about 30–35% by optimizing the database schema and queries.
• Robustness: built the offline-first ObjectBox store with bidirectional cloud sync and automatic reconciliation on reconnect, for reliable operation in low-connectivity field environments.
• Built the data-heavy screens on top of it: real-time charts, Gantt timeline views and multi-template report generation.
• Reworked the app's UI, navigation flow and data visualization, creating the wireframes with the engineering manager.
• Built Windows-scheduled reporting for LAN-connected devices, with customizable export configurations.
• Own the full release pipeline: build generation, versioning, packaging and distribution on every platform.

Beyond the code

I joined Halma as an intern in January 2024 and have been the primary developer on SyncIT since 2025.

• Spotted a production bottleneck and removed it. I proposed the settings application and built it with the firmware team. Manual production effort dropped by about 99%.
• Own releases on 3 platforms. Builds, versioning, packaging and distribution for Android, iOS and Windows, with Azure DevOps in the toolchain.
• Primary developer for a 25–30 person team. That means working with 6 disciplines in 3 countries: software, firmware, hardware, QA, project management and marketing.
• Keep delivery organised in Wrike. I create tasks, size them, distribute them across the team and track them through to release.
• Mentor juniors and colleagues on the codebase and help them get unblocked.
• Brought agentic tooling into daily engineering. I built a custom LLM agent harness and n8n automation for the team, and integrated BMAD and GSD into its workflow.

Stack: Flutter · Dart · Melos · ObjectBox · BLE · Wi-Fi, LAN and serial · Azure DevOps CI/CD · Wrike · n8n · Claude Code

flowchart LR
    INST[Gas-detection<br/>instruments]
    CAL[Calibration<br/>stations]
    BLE[BLE layer]
    NET[Wi-Fi · LAN · serial]
    SDK[Log-parsing SDK]
    CORE[Shared core package<br/>Melos monorepo]
    DB[(ObjectBox<br/>offline-first)]
    CLOUD[(Cloud sync)]
    LITE[SyncIT Lite<br/>Android · iOS · Windows]
    PLUS[SyncIT Plus<br/>reporting · integrations]
    OUT[Charts · reports · exports<br/>firmware updates · settings]

    INST --> BLE
    CAL --> NET
    BLE --> SDK
    NET --> SDK
    SDK --> CORE
    CORE <--> DB
    CORE --> LITE
    CORE --> PLUS
    PLUS <--> CLOUD
    LITE --> OUT
    PLUS --> OUT

    classDef hw fill:#0B1020,stroke:#0B1020,color:#fff
    classDef link fill:#4F46E5,stroke:#4F46E5,color:#fff
    classDef data fill:#0E7C6B,stroke:#0E7C6B,color:#fff
    classDef app fill:#7C3AED,stroke:#7C3AED,color:#fff
    classDef out fill:#C98A12,stroke:#C98A12,color:#fff
    class INST,CAL hw
    class BLE,NET,SDK link
    class CORE,DB,CLOUD data
    class LITE,PLUS app
    class OUT out

Halma plc

The part of my work I'd happily talk about all day. I build the systems around models, not the models themselves.

• Built a custom LLM agent harness for internal use — the orchestration layer that gives a model a tool surface, a context budget and a place to fail safely.
• Built internal automation on n8n workflow orchestration, wiring engineering tasks into repeatable pipelines.
• Researched and integrated agentic AI development frameworks — BMAD and GSD — into the team's daily engineering workflow.

What I work with: LLM APIs (Claude, OpenAI) · prompt engineering · RAG · vector search · agentic workflows · tool/function calling · n8n

The work above lives in a private codebase, so here are the same ideas, in public and runnable.

flowchart LR
    R[Request]
    P[Planner<br/>decompose the task]
    C[Context layer<br/>RAG · vector search]
    T{Tool surface}
    T1[Repo and files]
    T2[APIs and services]
    T3[Shell and CI]
    E[Execute step]
    V[Verify<br/>tests · checks]
    O[Result]

    R --> P
    P --> C
    C --> T
    T --> T1 & T2 & T3
    T1 & T2 & T3 --> E
    E --> V
    V -- needs another pass --> P
    V -- done --> O

    classDef entry fill:#0B1020,stroke:#0B1020,color:#fff
    classDef brain fill:#7C3AED,stroke:#7C3AED,color:#fff
    classDef tool fill:#4F46E5,stroke:#4F46E5,color:#fff
    classDef check fill:#0E7C6B,stroke:#0E7C6B,color:#fff
    class R,O entry
    class P,C brain
    class T,T1,T2,T3 tool
    class E,V check

End to end, most of my work is this path:

flowchart LR
    SRC[Data sources<br/>sensors · clients]
    API[NestJS<br/>REST API]
    Q[Kafka · BullMQ<br/>Redis]
    SVC[Services<br/>processing]
    DB[(PostgreSQL)]
    UI[Angular · Next.js<br/>HighCharts dashboards]
    AI[LLM agents<br/>n8n automation]
    K8S[Docker · Kubernetes<br/>CI/CD]

    SRC --> API
    API --> Q
    Q --> SVC
    SVC <--> DB
    SVC --> UI
    AI --> API
    DB --> AI
    K8S -.- API
    K8S -.- SVC

    classDef edge fill:#0B1020,stroke:#0B1020,color:#fff
    classDef back fill:#4F46E5,stroke:#4F46E5,color:#fff
    classDef data fill:#0E7C6B,stroke:#0E7C6B,color:#fff
    classDef front fill:#C98A12,stroke:#C98A12,color:#fff
    classDef ai fill:#7C3AED,stroke:#7C3AED,color:#fff
    class SRC edge
    class API,SVC back
    class Q,DB data
    class UI front
    class AI ai
    class K8S edge

Two more clients for the same instruments:

• .NET MAUI settings application — the app behind the 99% figure above. It configures ~50 instrument parameters through a guided UI, packaged as byte arrays and written to the instrument's Customer Profile region over BLE.
• React Native app — BLE data download, SQLite persistence and cloud sync across Android and iOS from one shared codebase, 40% less development effort.

Business Analyst (BA4) Intern   Pune, 2023

Built an automated testing framework with Java and Selenium WebDriver that raised coverage across critical workflows by 90%, and wired it into Jenkins to run on every commit.

Frontend

HighCharts · Flutter · React Native · .NET MAUI · Responsive and cross-browser work

Backend

REST APIs · Microservices · Message queues · BullMQ · ASP.NET

Data and messaging

SQL Server · LiteDB · ObjectBox · Vector search · Melos monorepos

AI and LLM

Agent harness · RAG · Vector search · Prompt engineering · Tool calling · BMAD / GSD

Cloud and DevOps

Azure DevOps · CI/CD · Multi-platform release pipelines (Android, iOS, Windows) · Wrike · Task planning and distribution

timeline
    2020 : AIR 8886 (99.22 percentile) in JEE Mains : Started B.Tech CSE at SVNIT Surat
    2023 : Business Analyst intern at Barclays, Pune : Java and Selenium test automation
    2024 : Graduated 5th of 135 with a 9.19 CGPA : Joined Halma plc as a Software Engineer
    2025 : Primary developer on SyncIT for Sensit instruments : Proof of concept to production-ready MVP
    2026 : SyncIT Lite and Plus on a Melos monorepo : Backend and dashboards on NestJS, Kafka and Angular : LLM agent harness and n8n automation for the team

flowchart LR
    U((Dhairya))
    U --- A[AI engineering]
    U --- F[Full stack]
    U --- S[Systems]
    U --- O[Off the keyboard]
    A --- A1[Agent harnesses]
    A --- A2[RAG and<br/>vector search]
    A --- A3[n8n automation]
    A --- A4[BMAD and GSD]
    F --- F1[NestJS and<br/>REST design]
    F --- F2[Next.js and<br/>Angular]
    F --- F3[PostgreSQL<br/>schema design]
    S --- S1[Event-driven<br/>architecture]
    S --- S2[Kafka and queues]
    S --- S3[Kubernetes]
    S --- S4[Release pipelines<br/>and DevOps]
    O --- O1[Formula 1]
    O --- O2[Mentoring juniors<br/>and colleagues]
    O --- O3[Hackathons]

    classDef root fill:#0B1020,stroke:#0B1020,color:#fff
    classDef ai fill:#7C3AED,stroke:#7C3AED,color:#fff
    classDef full fill:#4F46E5,stroke:#4F46E5,color:#fff
    classDef sys fill:#0E7C6B,stroke:#0E7C6B,color:#fff
    classDef off fill:#C98A12,stroke:#C98A12,color:#fff
    class U root
    class A,A1,A2,A3,A4 ai
    class F,F1,F2,F3 full
    class S,S1,S2,S3,S4 sys
    class O,O1,O2,O3 off

• 🤖 Building agentic tooling into daily engineering. n8n orchestration, a custom LLM agent harness, and frameworks like BMAD and GSD — the goal is an agent that reliably finishes a task, not one that demos well.
• 🔍 Going deeper on RAG and retrieval. Chunking strategies, hybrid search and rank fusion, and how much context is actually worth paying for — most of it ends up in rag-service.
• 📡 Growing SyncIT past its MVP. Two product variants on one Melos monorepo, a shared core package, a log-parsing SDK, and the device communication layer underneath both.
• ⚙️ Scaling the backend. Event-driven architecture, concurrency and fault tolerance, for when sensor data arrives faster than one service can handle.
• 🌍 Contributing upstream, one CI blind spot at a time. 50 changes merged into Apache Camel, Elasticsearch, Quarkus, Home Assistant, typeshed, the PEPs, Netty, Micronaut, more-itertools, drift and the Dart SDK repos — each one a defect the project's own linters and test suites could not reach — and 40 more in review.
• 🧩 Keeping fundamentals sharp in my DSA repo.

I hunt one class of bug on purpose: the kind a project's CI structurally cannot catch. A default hidden behind **kwargs that stubtest has no parameter to compare against. A log line whose placeholders outnumber its arguments. A hand-written catalog entry that drifts from the enum it describes. A format string that throws the moment debug logging is switched on. Linters do not look there, so the defects sit in released code for years.

Merged into Apache Camel, Elasticsearch, Quarkus, Home Assistant, CPython's PEPs, typeshed, Netty, Micronaut, more-itertools, drift and Google's shelf and native — 50 changes, every one a defect their own tooling could not see. Status below is live as of 12 Nov 2026.

Every typing change is verified the same way before it goes out: stubtest against the real installed package, then mypy --strict and pyright on a usage file full of assert_type, so the error count before and after is the evidence.

Open at the time of writing. I only count a change once maintainers merge it; these are listed so the status is visible, not to pad the number.

Happy to talk about full-stack architecture, event-driven backends, or putting LLM agents somewhere they actually earn their keep.

📫 ozadhairya73@gmail.com · LinkedIn · Portfolio