Founder · Product & Architecture
A distributed time tracking and activity intelligence platform: desktop agent, web apps and event-driven microservices, designed and shipped end to end.
Product components
Desktop agent, web apps and backend services
NestJS microservices
Independently deployable domain services
Fewer immediate writes
Batching on the ingest path cuts write amplification
TrackHRS is a full-stack time tracking and activity intelligence platform for distributed teams. It combines a native desktop agent, two web applications and a set of event-driven microservices that capture work activity, classify it, and turn it into analytics HR and operations teams can act on.
The hard part was never the dashboard. It was the path between a keystroke on someone’s laptop and a number a manager is willing to trust. That path has to stay accurate when the network drops, stay fast when traffic spikes, and never double-count an event because two replicas processed it at once.
I designed the architecture around asynchronous pipelines, cache-first reads and multi-replica-safe processing, so each of those failure modes is handled by a specific mechanism rather than by hope.
Time captured across tasks and projects with reliable aggregation, even when a laptop goes offline mid-session.
Automated categorisation of activity so operational insight does not depend on people filling in timesheets.
Dashboards and reporting that HR, managers and operations teams can act on in near real time.
Four layers, each scaling on its own terms. Clients never talk to storage directly, and nothing time-sensitive shares a path with anything slow.
What people actually use
Domain services behind REST and gRPC boundaries
Where slow work is decoupled from fast work
Durable state
Each service owns one domain and can be deployed, scaled and owned independently.
Tauri desktop agent for activity capture and local runtime
Activity ingestion and classification orchestration
Read and statistics APIs for dashboards and reporting
ML and rule-based classification service
Auth, users, organisations, leave and payroll core domain
Project and task time duration aggregation
Subscription and billing domain
Email and notification processing
Object upload pipeline for screenshots and artefacts
Desktop release and update distribution server
Public marketing site and lead capture
Authenticated operations and admin experience
This is the core of the product. Every step exists to solve a specific failure mode: duplicate events, write amplification, a slow model call blocking ingest, or a stale dashboard. Read top to bottom, it is the journey from one keystroke to one number on a manager’s screen.
Captured by the Tauri agent and sent over a secure API boundary. If the network is down, it buffers locally in SQLite first.
High-throughput ingestion, deliberately decoupled from everything downstream so a slow consumer can never slow down capture.
Processes the stream with partition-aware scaling, so adding replicas grows throughput with the consumer group.
An O(1) key check makes processing multi-replica-safe, so the same event is never counted twice.
Collects up to 100 items or a 5-second window before writing, giving up to 100× fewer immediate database writes on the hot path.
A document model that fits evolving activity payloads and organisation structures, paired with indexed reporting queries.
Classification runs as a background job, keeping latency-sensitive writes off the same path as heavier work.
A bearer-key FastAPI service, so the ML lifecycle and its dependencies iterate independently of the TypeScript services.
Categories are persisted. Failures fall through a circuit breaker, exponential retry and a dead-letter collection that a distributed cron reprocesses.
An invalidation event means the next dashboard read is fresh, without depending on a short TTL to expire.
Event streaming
Apache Kafka
Decouples ingestion from downstream processing and supports replay-friendly analytics workloads at high throughput.
Background work
BullMQ
Classification and delayed jobs stay off the hot path, so latency-sensitive writes stay fast.
Cache & coordination
Redis Cluster
One system covers cache acceleration, deduplication, queue backing and the distributed locks that make cron multi-replica-safe.
Persistence
MongoDB replica set
Flexible documents suit evolving activity payloads and org structures, and pair naturally with batched upserts.
Desktop client
Tauri 2 + Rust
Native-level performance and low memory overhead, with the system-level access browser-only approaches cannot reach.
ML service
Python FastAPI
Keeps model iteration and Python dependencies fully isolated from the strongly typed core platform.
Rust desktop agent, modern web apps and microservices delivered end to end.
Batching on the ingest path substantially reduces write amplification.
Kafka and BullMQ absorb traffic spikes and keep pipelines resilient.
Redis dedup keys and distributed locks keep cron and background work idempotent.
A dedicated Python classifier while the core platform stays strongly typed in TypeScript.
Desktop app, admin portal, marketing site, update server and the backend ecosystem behind them.
If any of the problems above look familiar, I can help, whether that's a full architecture or a second opinion on the one you have.
Open to remote and hybrid work worldwide