Ground TruthJalandhar, IndiaOpen to internship and new-grad software engineering roles

Ronit Saha

Full-stack & systems engineer

I build systems the way they'll have to be maintained. I design and build the layers between a model and a person — transactional backends, on-device perception, cross-language static analysis. The architecture is written down before the code, and every figure on this page links to the artifact it was measured from.

Systems
6
Readings
28
Ground samples
47
Languages
5

Position

Where I am, stated as measurements rather than adjectives. Every figure opens the artifact it was counted from.

I'm a computer science undergraduate at Lovely Professional University, and most of what I know came from building systems slightly larger than I was ready for.

The pattern is visible in the repositories. TerraMind started as “process a satellite image” and became a platform with a transactional repository layer and a job pipeline, because each of those turned out to be the honest answer to a problem I had actually hit. HealthTrack started as a reminder app and became an exercise in what it takes for a notification to survive a reboot.

The last year changed the shape of the work rather than the size of it. Cartograph and PratiBimb are both codebases with other people in them, which means most of my recent output is a reviewed pull request rather than a commit I pushed to my own main — and it means the interesting skill stopped being “can I build this” and started being “can I write down the decision so the next person does not have to guess.”

I work specification-first: write the architecture down, decompose it into small phases, and keep the history readable enough that a stranger could follow the reasoning. Slower for a day, considerably faster after that.

Education
B.Tech Computer Science · Lovely Professional University
Focus
Backend · Systems · Geospatial · Privacy engineering · Android

Selected systems

Six, in two tiers. The three at the top have an architecture worth several screens and get one each; the three below are real work that does not need that much room. Every one states what is wrong with it.

01Privacy · Perception2026

A browser agent that can see your screen and act on it without your screen ever reaching the server. Sensitive spans leave as typed placeholders; the client substitutes the real value at the instant of execution.

STATUSA working, measured prototype on one machine — not a release. Milestones through M21 are merged: the extension reads a page's structure locally, hands a sanitised and verified view to a small reasoner on loopback, and executes through the gate. It runs against synthetic pages only, and the visual detector is not adopted.

TypeScript (strict)WXT · Chrome MV3ONNX Runtime WebWebGPU / WASM SIMDVitestPlaywright + CDP
Commits · attributed
384 / 535
Benchmark tasks completed · one machine
6 / 6
Frozen security invariants
25
Recorded experiments
99
02Static analysis · Graphs2026

Follow a TypeScript click handler across an HTTP boundary into a Python route, through an ORM model, to the database table it writes — with the evidence for every hop attached to the edge.

STATUSVersion 0.1.0. Milestones M00 to M16 are accepted and M17, the public launch, is in progress. One analysis core serves a CLI, a desktop application, an MCP server and a pull-request review workflow.

Rust 1.97tree-sitterpetgraphredbTauri v2React 19
Commits · attributed
94 / 327
Milestones · mine
M11–M16
Merged pull requests
67 / 95
Edges measured · 7 repositories
14932
03Geospatial · Platform2026

Satellite scenes in, segmented geometry and spectral statistics out — with a job platform underneath so nothing blocks a request.

STATUSNot deployed. Ruff, mypy and pytest all gate a push since August 2026; the specification volumes have been removed from the default branch and survive only in history.

Python 3.11FastAPISQLAlchemy (async)PostgreSQL + PostGISCeleryRedis
Commits · sole author
122
Tracked source files
472
Test modules · gating CI
45
Specification volumes
9
Also in the record
04Agents · Local-first

A voice agent that runs entirely on your own machine, with a real-time dashboard streaming its state over WebSocket and an automation layer that lets it act on the system.

Python 3.11Next.js 15TypeScriptWebSocketshared
05Android · Reliability

A reminder that fires late is a reminder that failed. Built so scheduling survives reboots, timezone shifts and clock changes.

KotlinJetpack ComposeMVVMHilt
06Full-stack · Team

Eight commits inside a four-person codebase: the surplus-food endpoints, the model and validators, the dashboard integration and the deploy config.

TypeScriptExpressMongoDBReactshared

Privacy · Perception · 2026 · On-device visual perception for browser agents

PratiBimb

A browser agent that can see your screen and act on it without your screen ever reaching the server. Sensitive spans leave as typed placeholders; the client substitutes the real value at the instant of execution.

Status

A working, measured prototype on one machine — not a release. Milestones through M21 are merged: the extension reads a page's structure locally, hands a sanitised and verified view to a small reasoner on loopback, and executes through the gate. It runs against synthetic pages only, and the visual detector is not adopted.

Ownership

Two-person team. 384 of 535 commits and 39 of 83 merged pull requests are mine; Lakshya172 wrote the rest. I own the repository, the engineering governance layer and the review process, and I merge.

  • TypeScript (strict)
  • WXT · Chrome MV3
  • ONNX Runtime Web
  • WebGPU / WASM SIMD
  • Vitest
  • Playwright + CDP
  • llama.cpp · Qwen2.5-0.5B (local)
The problem

The obvious build — screenshot, blur the faces, send it to a vision model — fails the moment you try to use it. Black out the user's phone number and the server can no longer instruct the agent to type the phone number. Privacy has eaten the product. Redaction that is merely destructive turns a working agent into a blind one, and that is the gap the problem statement actually leaves open.

The invariant

Nothing crosses the wire until the verifier passes, and nothing executes until both the allowlist and the freshness check pass. A literal that matches a value held in the vault is treated as a leak and halts the session.

The approach

A twelve-stage pipeline with two gates in it. Six local stages surround a single server call: observe, perceive, sanitize, verify — then the server reasons and plans — then validate, refresh, re-hydrate, act, verify the result. Stage 4 is the egress gate and stages 7 and 8 together are the execution gate; no stage may be removed, reordered or made conditional. Every sensitive span becomes a typed placeholder carrying the shape of the data without its content, so the server sees that there is a twelve-digit numeric field labelled Aadhaar at a known coordinate and can plan around it. The real value lives in a memory-only vault the client alone can read. Every model role sits behind a frozen typed interface, so a model is a replaceable component and the architecture is not wired around any particular one. In the phase that ships today the reasoner is a small local model on loopback and sees structure only; reasoning over frames is registered as a later phase and is not authorised.

Path through the system
  1. 01Observe

    Capture the visible tab plus the DOM.

  2. 02Perceive

    Elements, roles and faces, on the device.

  3. 03Sanitize

    Detect sensitive spans and replace each with a typed placeholder.

  4. 04VerifyGate

    The egress gate. Fail-closed — the verifier can block a send, and is never advisory.

  5. 05Reason

    The server plans over a redacted frame. Untrusted with respect to PII.

  6. 06Plan

    An action returned as JSON, addressed in placeholders.

  7. 07Validate

    Checked against a local allowlist. The client never trusts the server.

  8. 08Refresh

    Is the target still real? Role, name, visibility and position re-checked against the live page.

  9. 09Re-hydrate

    The vault substitutes the real value. Memory-only, destroyed on origin change.

  10. 10Act

    Execute against the page.

  11. 11Verify result

    Confirm the postcondition held.

  12. 12Repeat or ask

    Continue, or stop and ask the user.

Architecture · 5 layers · request order, top to bottom
  1. 01Perception

    Capture, preprocessing, the UI detector head, the element graph and DOM/vision fusion. The largest package and the highest-risk interface in the project.

    • packages/perception/src/capture.ts
    • packages/perception/src/fusion.ts
    • packages/perception/src/uiDetectorHead.ts
  2. 02Security

    The CSP contract, the WASM capability gate and the ONNX Runtime pin — the runtime asset is hash-pinned and checked in CI.

    • packages/security/src/csp.ts
    • packages/security/src/wasmCapability.ts
    • packages/security/src/ortRuntimePin.ts
  3. 03Agent

    The execution gate. Action freshness, hit-test agreement, the dispatch permit and result verification — nothing executes without all four.

    • packages/agent/src/guardedAct.ts
    • packages/agent/src/actionFreshness.ts
    • packages/agent/src/permit.ts
  4. 04Transport

    Typed page-transport contracts, a stateless service-worker router, and observation bound to one attested document.

    • packages/extension-transport/src/swRouter.ts
    • packages/extension-transport/src/pageAgent.ts
    • packages/extension-transport/src/coreTransport.ts
  5. 05Evaluation

    The measurement harness — dataset, generator, labels, baselines and the threshold rule. Built in week two, as the principles require, not week six.

    • packages/evaluation/src/evaluator.ts
    • packages/evaluation/src/dataset.ts
    • packages/evaluation/src/baselines.ts

Read these files in the repository

The hard part

The test vehicle was measurably blind to the send path

The whole project rests on one claim: nothing leaves the machine unverified. Proving it needs a harness that can observe the extension's egress — and the spike that checked this returned a worse answer than the question. Playwright's `context.route()` does not cover the MV3 offscreen document, which the constitution makes the send path. Under a route handler set to abort everything, the offscreen POST still reached the wire, in three runs of three. A suite written that way would assert zero outbound requests, pass, and prove nothing at all. The finding was recorded as a blocker rather than worked around, the quality gate was marked unsignable on the existing plan, and the follow-up attached CDP to the offscreen target with an independent loopback collector — which observes, genuinely blocks, detects an unauthorised sender by absent provenance, and caught a tampered payload by recomputing its hash.

Readings · every figure links to what it was measured from
What is wrong with it

It runs on one Windows machine, against synthetic pages on loopback, and nowhere else. The visual UI detector is not adopted, so the shipped path reads DOM structure — protection of personal data that exists only as pixels is not demonstrated, and the brief's visual deliverables are deferred. Every step calls the model; there is no cache. The benchmark is six tasks on a single machine, with no reliability rate and no cross-machine claim, and the repository records its own health as amber with several owner decisions still open.

Exactly what is mine — 5 items
  • The AgentOS engineering layer: seven specialist reviewer contracts, four workflows, quality gates QG-01 to QG-06, and the model registry and feasibility matrix
  • The frozen contracts — architecture constitution, twenty-five security invariants, threat model, coordinate contract, redaction manifest and action schema
  • The W1 to W2 handoff: evidence index, artifact manifest, repository inventory, reproduction guide and the preflight verifier
  • Repository CI — governance verification, secret and PII-shape scanning, dossier integrity, conventional-commit enforcement and the spike-phase guard on apps/ and packages/
  • Review and merge of the perception, agent, security and transport packages

System complete01 / 06

Plate 01What is allowed to leave

The whole systemRead the two cards across the gate. The shape of every field survives the crossing; not one identifying character does.

01 ObserveCapture the visible tab plus the DOM.

02 PerceiveElements, roles and faces, on the device.

03 SanitizeDetect sensitive spans and replace each with a typed placeholder.

04 Verify · gateThe egress gate. Fail-closed — the verifier can block a send, and is never advisory.

05 ReasonThe server plans over a redacted frame. Untrusted with respect to PII.

06 PlanAn action returned as JSON, addressed in placeholders.

07 ValidateChecked against a local allowlist. The client never trusts the server.

08 RefreshIs the target still real? Role, name, visibility and position re-checked against the live page.

09 Re-hydrateThe vault substitutes the real value. Memory-only, destroyed on origin change.

10 ActExecute against the page.

11 Verify resultConfirm the postcondition held.

12 Repeat or askContinue, or stop and ask the user.

Plate 01What is allowed to leave

The whole systemRead the two cards across the gate. The shape of every field survives the crossing; not one identifying character does.

01 ObserveCapture the visible tab plus the DOM.

02 PerceiveElements, roles and faces, on the device.

03 SanitizeDetect sensitive spans and replace each with a typed placeholder.

04 Verify · gateThe egress gate. Fail-closed — the verifier can block a send, and is never advisory.

05 ReasonThe server plans over a redacted frame. Untrusted with respect to PII.

06 PlanAn action returned as JSON, addressed in placeholders.

07 ValidateChecked against a local allowlist. The client never trusts the server.

08 RefreshIs the target still real? Role, name, visibility and position re-checked against the live page.

09 Re-hydrateThe vault substitutes the real value. Memory-only, destroyed on origin change.

10 ActExecute against the page.

11 Verify resultConfirm the postcondition held.

12 Repeat or askContinue, or stop and ask the user.

Decisions · 3 recorded, rejected options kept
DecisionTyped placeholders, not destructive redaction
Context

The problem statement requires that only anonymised data is transmitted, and that the server returns an action the browser agent executes. Those two requirements pull in opposite directions: an agent cannot be told to type a value the server was never shown.

Options
  • Black out the sensitive region and send the image — The server can no longer address the field it cannot see. Privacy holds and the product stops working.

  • Send the values and trust the server to discard them — Makes the privacy claim a policy promise rather than an architectural property. Unverifiable from the client.

  • Replace each span with a typed placeholder and keep the real value client-side — The server keeps enough structure to plan and never enough content to identify.

Decision

Every sensitive span becomes a placeholder carrying its class and index — the shape of the data, never its content. A memory-only vault holds the real values, and the client substitutes at the instant of execution.

Consequence

The server is functionally complete and structurally blind. The cost is a re-hydration step that must never run before validation and freshness have both passed, which is why those are separate stages rather than one check.

DecisionRe-check the target after the screenshot and before the click
Context

A plan is made from a frame captured some milliseconds ago. Between the capture and the click, the page can swap a benign control for a harmful one, and the coordinates would still be correct.

Options
  • Trust the coordinates from the frame the plan was made on — Leaves an exploitable window in which the page rewrites the target under a valid plan.

  • Re-capture and re-plan before every action — Doubles the server round trips and the latency budget, for a check that is local and cheap.

  • Re-validate the target against the live DOM immediately before dispatch — Local, fast, and it closes the window without another model call.

Decision

Stage 8 re-checks that the element still exists, that its role and accessible name still match what was reported to the server, that it is visible and enabled, and that its bounding box has not moved beyond tolerance. A failure discards the plan and re-observes.

Consequence

The agent occasionally throws away a valid plan and starts again. It never guesses, and it never clicks a control that was substituted after the frame was taken.

DecisionRecord the spike that invalidated the test plan
Context

S-01b asked whether Playwright could observe extension egress. The answer was that it cannot see the MV3 offscreen document — the exact path the constitution designates for sending — so the planned test vehicle could not prove the project's central claim.

Options
  • Keep the Playwright suite; it passes — It passes by not observing anything. A green suite that cannot fail is worse than no suite, because it stops people looking.

  • Move the send path somewhere Playwright can see — Changing frozen architecture to suit a test tool is the wrong direction of causation.

  • Record it as a blocker, mark the gate unsignable, and find an instrument that can see the real path — The claim is the product. An instrument that cannot measure it has to be replaced, not accommodated.

Decision

S-01b was merged with a CONDITIONAL verdict, QG-04 was marked unsignable on the existing enforcement plan, and B-02 was opened. The replacement attaches CDP to the offscreen target with an independent loopback collector.

Consequence

The project carries a visible amber blocker instead of a green test suite. That is the accurate state, and the register says so on the front page.

Static analysis · Graphs · 2026 · Architectural intelligence engine

Cartograph

Follow a TypeScript click handler across an HTTP boundary into a Python route, through an ORM model, to the database table it writes — with the evidence for every hop attached to the edge.

Status

Version 0.1.0. Milestones M00 to M16 are accepted and M17, the public launch, is in progress. One analysis core serves a CLI, a desktop application, an MCP server and a pull-request review workflow.

Ownership

Contributor to a project led by Soumyadeb Tripathy. 94 of 327 commits and 67 of 95 merged pull requests are mine. The analysis engine — parser, resolver, graph and calibration, milestones M00 to M10 — is not mine; milestones M11 to M16 are.

  • Rust 1.97
  • tree-sitter
  • petgraph
  • redb
  • Tauri v2
  • React 19
  • Sigma.js · Graphology
  • TypeScript
  • Model Context Protocol
  • criterion
  • GitHub Actions
The problem

Every tool in this category draws a file-level import graph and calls it architecture. Ask one what a checkout button touches and it answers with the files that import each other. That is a lexical fact, and the question was a causal one. The gap between them is where production incidents live — and closing it means partially evaluating dynamically constructed URLs, normalising four route-declaration dialects and resolving ORM models to tables, which are compiler problems no API call can answer.

The invariant

No edge exists without the evidence for it. `Edge` has no `Default`, no public fields and one constructor that requires source, target, kind, confidence, provenance, evidence, source location and commit — so an unevidenced relationship cannot be constructed, let alone stored.

The approach

One Rust core, three clients. The core owns the domain model, the graph, tree-sitter extraction and the resolver; the CLI, the desktop app and the MCP server are peers that hold no analysis logic, which is checked by a quality gate rather than left to discipline. My work is the client half and the AI boundary: I built the desktop application on Tauri v2 with the graph rendered by Sigma over Graphology, then blast radius and structural diff as core traversals surfaced identically through CLI and desktop, then the GitHub Action that posts an architecture review on pull requests, then the MCP server over stdio with a session authorization boundary — and then the ASK boundary, where an evidence bundle, a degraded path that answers with no model at all, tracing-layer redaction and a per-repository opt-in all exist before any provider does.

Path through the system
  1. 01Source

    A TypeScript call site. tree-sitter reports observed syntax, never a resolved relationship.

  2. 02Symbol graph

    Symbols, imports, call sites and template structure, per language.

  3. 03Canonical route

    /orders/:id, /orders/{id} and /orders/<int:id> all become the shape /orders/{*}.

  4. 04HTTP boundaryGate

    The cross-language join. Ambiguous candidates produce no edge rather than a guess.

  5. 05Handler

    The Python route that answers it, matched on method and every path segment.

  6. 06ORM model

    Model construction resolved back to the class that declares the mapping.

  7. 07Table

    The database table the model writes. Three domains crossed: code, HTTP and data.

Architecture · 5 layers · request order, top to bottom
  1. 01Clients

    Mine, except the CLI. Desktop (M11), MCP server (M15) and the GitHub reviewer (M14) are peers of one graph API and hold no analysis logic — enforced by QG-006, not by convention.

    • crates/cartograph-desktop
    • crates/cartograph-mcp
    • desktop/src/GraphView.tsx
  2. 02ASK boundary

    Mine. Evidence bundle, the degraded answer, the credential boundary and the provider transport seam. No model may propose an edge — ever.

    • crates/cartograph-ask
    • desktop/src/ask.ts
  3. 03Graph

    The architecture graph over petgraph, traversal, layout, blast radius and structural diff. The crate is shared; M12 and M13 within it are mine.

    • crates/cartograph-graph
    • crates/cartograph-pipeline
  4. 04Resolver

    Not mine. Canonical routes, route matching, partial evaluation of dynamic URLs and ORM model resolution — the compiler problems the product exists to solve.

    • crates/cartograph-resolver
  5. 05Core and parser

    Not mine. The domain model — nodes, edges, evidence, provenance, confidence — and tree-sitter extraction for TypeScript, TSX and Python.

    • crates/cartograph-core
    • crates/cartograph-parser

Read these files in the repository

The hard part

Giving a language model a seat that cannot reach the graph

ADR-0007 makes it immutable that no model ever constructs graph structure. A model may explain a subgraph after static analysis has produced it; it may never propose an edge. Honouring that while still shipping an AI feature means the interesting work is all boundary design rather than prompting. ASK receives an evidence bundle assembled from the graph, not the repository, so there is no path by which a provider can see source it was not given. The degraded answer — the response with no model attached — was built in the first slice, before any provider existed, so the feature is useful with no API key and the model is genuinely optional rather than nominally so. Redaction sits in the tracing layer, so a value cannot be logged by a call site that forgot; credentials live in the OS keychain and reach the process as a grant in argv rather than a file on disk; and the provider transport is a seam, so the Groq wire types are an implementation behind it instead of the shape of the feature.

Readings · every figure links to what it was measured from
What is wrong with it

The accuracy figures are upper bounds and the report says so: 24.9% of edges could not be verified from source, and that quarter concentrates where the evidence is weakest rather than falling randomly. Confidence values are uncalibrated priors, not probabilities, and must not be thresholded as if they were — calibration error runs at 0.18 toward under-confidence. Only TypeScript, TSX and Python are extracted. The desktop shell is outside the cargo workspace and so outside `cargo test --workspace`, and its CI job runs on Linux and macOS only, which is the price of keeping the gates buildable without a system webview.

Exactly what is mine — 6 items
  • M11 — the Tauri v2 desktop application: the Rust layout contract, repository lifecycle, the Sigma-over-Graphology renderer and edge evidence inspection
  • M12 — blast radius: the core traversal, the CLI command and the desktop surface
  • M13 — structural diff branch against branch, stable cross-run node identity and a mental-map-stable layout
  • M14 — the GitHub Action that renders an architecture review as Markdown and posts it on pull requests
  • M15 — the MCP server over stdio, the session authorization boundary, and extracting trace traversal into the graph crate
  • M16 — the ASK boundary: the evidence bundle, the degraded answer with no model, tracing-layer redaction, the per-repository opt-in and credential boundary, and the provider transport seam

System complete02 / 06

Plate 02One relationship, all the way down

The whole systemA TypeScript function, an HTTP boundary, a Python handler, a SQLAlchemy model and a table — no shared symbol table, and every hop carries its own evidence.

01 SourceA TypeScript call site. tree-sitter reports observed syntax, never a resolved relationship.

02 Symbol graphSymbols, imports, call sites and template structure, per language.

03 Canonical route/orders/:id, /orders/{id} and /orders/<int:id> all become the shape /orders/{*}.

04 HTTP boundary · gateThe cross-language join. Ambiguous candidates produce no edge rather than a guess.Evidence: POST /api/v2/connections/enqueue-test matched the route at connections.py:383 — exact HTTP method, every path segment static and equal.

05 HandlerThe Python route that answers it, matched on method and every path segment.

06 ORM modelModel construction resolved back to the class that declares the mapping.Evidence: ConnectionTestRequest(...) constructed in enqueue_connection_test at connections.py:427.

07 TableThe database table the model writes. Three domains crossed: code, HTTP and data.Evidence: ConnectionTestRequest maps to the table connection_test_request.

Plate 02One relationship, all the way down

The whole systemA TypeScript function, an HTTP boundary, a Python handler, a SQLAlchemy model and a table — no shared symbol table, and every hop carries its own evidence.

01 SourceA TypeScript call site. tree-sitter reports observed syntax, never a resolved relationship.

02 Symbol graphSymbols, imports, call sites and template structure, per language.

03 Canonical route/orders/:id, /orders/{id} and /orders/<int:id> all become the shape /orders/{*}.

04 HTTP boundary · gateThe cross-language join. Ambiguous candidates produce no edge rather than a guess.Evidence: POST /api/v2/connections/enqueue-test matched the route at connections.py:383 — exact HTTP method, every path segment static and equal.

05 HandlerThe Python route that answers it, matched on method and every path segment.

06 ORM modelModel construction resolved back to the class that declares the mapping.Evidence: ConnectionTestRequest(...) constructed in enqueue_connection_test at connections.py:427.

07 TableThe database table the model writes. Three domains crossed: code, HTTP and data.Evidence: ConnectionTestRequest maps to the table connection_test_request.

Decisions · 3 recorded, rejected options kept
DecisionThe model explains the graph; it never proposes an edge
Context

Cartograph's differentiator is that every relationship carries evidence. A language model can produce a plausible edge with no evidence at all, and a single such edge would make the whole graph's evidence claim meaningless.

Options
  • Let the model propose edges the resolver could not find — Recall would improve and the product's one claim would be destroyed. An unevidenced edge is indistinguishable from a wrong one.

  • Let it propose edges, flagged as low confidence — A flag is a convention. Conventions get dropped downstream, and the confidence values are already documented as uncalibrated priors.

  • Deterministic analysis first, evidence second, inference third, the model last and never in the graph — Makes it structural. The model reads an evidence bundle assembled from the graph and cannot write back to it.

Decision

ADR-0007 states it as an immutable architectural principle rather than a current limitation. ASK is downstream of the graph by construction.

Consequence

The AI feature is strictly explanatory and the graph stays checkable. The upside is that answering with no model is a legitimate mode, which is why the degraded path was the first slice built rather than a fallback added later.

DecisionThe desktop shell sits outside the cargo workspace
Context

Tauri links a system webview. No milestone from M00 to M10 had ever needed GUI libraries to be present for the gates to run, and the gates are what make a milestone complete.

Options
  • Add the Tauri crate to the workspace — Every existing gate would then need a webview installed to build. Ten milestones of CI would become dependent on a GUI toolchain.

  • Put the analysis logic in the shell so it has something to test — Directly violates the rule that clients hold no analysis logic, and would have been the third copy of it.

  • Keep the shell outside, and make it short enough that the gap does not matter — `cartograph-desktop` holds validation, orchestration and the error contract with no Tauri dependency, so the workspace gates still cover the logic.

Decision

ADR-0016 draws the boundary: the shell is two commands long, the logic lives in a Tauri-free crate inside the workspace, and a separate CI job builds the shell on Linux and macOS.

Consequence

The shell is not covered by `cargo test --workspace`, and Windows is not covered by its CI job. Both are stated in the changelog rather than left for someone to discover.

DecisionIdentity arrives as a grant in argv, not from the environment
Context

The MCP server is launched by an agent host and asked to answer questions about a repository. It has to know which repository it is authorised for, and it must not be persuadable by anything it reads.

Options
  • Infer the repository from the working directory — The process's own cwd is not an authorisation. Whoever launched it decides, not wherever it happens to be standing.

  • Read a credential file from disk — Puts a secret on disk for a process whose privacy claim is that nothing leaves the machine. Credentials belong in the OS keychain.

  • Require an explicit grant at launch — The authorisation is supplied by the launcher, is visible in the process's own arguments, and a tree that was not granted is refused.

Decision

A session authorization boundary takes a grant in argv. A repository this session was not granted is refused, and identity is grant-supplied rather than derived.

Consequence

The host has to be explicit, which is slightly more configuration. In exchange, there is no ambient state from which the server can be talked into answering about the wrong tree.

Geospatial · Platform · 2026 · Earth intelligence platform

TerraMind AI

Satellite scenes in, segmented geometry and spectral statistics out — with a job platform underneath so nothing blocks a request.

Status

Not deployed. Ruff, mypy and pytest all gate a push since August 2026; the specification volumes have been removed from the default branch and survive only in history.

Ownership

Sole author. All 122 commits, no co-authors, no merged forks.

  • Python 3.11
  • FastAPI
  • SQLAlchemy (async)
  • PostgreSQL + PostGIS
  • Celery
  • Redis
  • Alembic
  • PyTorch
  • React 19
  • TypeScript
  • deck.gl 9
  • MapLibre GL
  • Zustand
  • Vite
The problem

Running a segmentation model over a satellite scene takes minutes, not milliseconds. Any design that treats it as a request/response call is broken before it ships: the request times out, the work is lost, and there is no record that it ever happened. The real problem was never the model — it was everything around it.

The invariant

A unit of work either completes and is recorded, or it fails and is recorded. There is no third state where analysis happened but nothing knows about it.

The approach

The backend is layered strictly by responsibility. Routers hold no logic; they call services, services call repositories, and nine repositories sit behind a single Unit of Work that hands every one of them the same async session — so a request commits as one transaction or rolls back as one. Long work never runs inline: it is dispatched to Celery, tracked as a database row through a job lifecycle, and its result is written back with a lineage record attached. External services — the STAC catalogue, the tile server, the segmentation model — each sit behind a base interface, so adding a second provider is a registration rather than a rewrite. The client is a MapLibre globe with a deck.gl overlay, a store per domain, and an adapter between the two so interaction handling reaches into neither.

Path through the system
  1. 01API

    Versioned routers holding no business logic.

  2. 02Services

    Orchestration. Owns no persistence and no HTTP.

  3. 03Unit of WorkGate

    The transaction boundary. Nine repositories share one async session — a request commits or rolls back as one.

  4. 04Job platform

    Celery and a Redis-backed store. Jobs are database rows, not fire-and-forget.

  5. 05Inference

    A provider registry. A second model is a registration, not a rewrite.

  6. 06Geospatial

    Polygonisation, spectral indices and zonal statistics.

Architecture · 6 layers · request order, top to bottom
  1. 01API

    Versioned routers with no business logic. Dependency-injected, typed request and response schemas.

    • src/api/v1/router.py
    • src/api/v1/analysis.py
    • src/api/dependencies.py
  2. 02Services

    Orchestration. Decides what happens; owns no persistence and no HTTP.

    • src/services/analysis_service.py
    • src/services/catalog_service.py
    • src/services/tile_service.py
  3. 03Unit of Work

    Transaction boundary. Nine repositories share one async session so a request commits or rolls back as a single unit.

    • src/unit_of_work.py
    • src/repositories/base.py
  4. 04Job platform

    Celery app, task registry, Redis-backed job store. Jobs are first-class rows, not fire-and-forget.

    • src/async_processing/service.py
    • src/async_processing/redis_store.py
    • src/async_processing/tasks/ai_tasks.py
  5. 05Inference

    Provider registry with a loader and a tensor pre/post-processing pipeline. A second model is a registration.

    • src/ai/registry.py
    • src/ai/providers/segformer.py
    • src/ai/processing/preprocessor.py
  6. 06Geospatial

    Raster polygonisation, geometry processing, GeoJSON export, spectral indices and zonal statistics.

    • src/geospatial/polygonizer.py
    • src/analytics/indices/ndvi.py
    • src/analytics/statistics/engine.py

Read these files in the repository

The hard part

Making a job something the database knows about

Celery will happily run a task and hand you a result id, and for about a week that feels like it solves the problem. It does not, because the result backend is not the system of record: restart the broker and the work is gone with no trace that it was ever requested, and there is nowhere to put the question a user actually asks, which is what happened to the thing I submitted an hour ago. So a job is a row. Job is a real table with a type, a status enum, a priority and separate submitted, started and completed timestamps, foreign-keyed to the project and region it belongs to — which means a queued job, a running job and a job that died mid-flight are all distinguishable after a restart, and the audit log has something to point at. The store itself sits behind JobStoreProtocol, with an in-memory implementation beside the Redis one, so the lifecycle is testable without standing up a broker. The hard part was declining the version that worked immediately.

Readings · every figure links to what it was measured from
What is wrong with it

It is not deployed. The nine specification volumes are also no longer on the default branch — they exist only in the commit that added them, which is why the link here is pinned to that SHA rather than to `main`. Until recently this site also said pytest was commented out in CI; that was fixed in August and the claim here was stale, which is exactly the failure the site exists to argue against.

System complete03 / 06

Plate 03A request down, a raster back as shape

The whole systemAbove, the backend a request descends through. Below, what it is for: a tile becomes a mask, and a mask becomes geometry a database can hold.

01 APIVersioned routers holding no business logic.

02 ServicesOrchestration. Owns no persistence and no HTTP.

03 Unit of Work · gateThe transaction boundary. Nine repositories share one async session — a request commits or rolls back as one.

04 Job platformCelery and a Redis-backed store. Jobs are database rows, not fire-and-forget.

05 InferenceA provider registry. A second model is a registration, not a rewrite.

06 GeospatialPolygonisation, spectral indices and zonal statistics.

Plate 03A request down, a raster back as shape

The whole systemAbove, the backend a request descends through. Below, what it is for: a tile becomes a mask, and a mask becomes geometry a database can hold.

01 APIVersioned routers holding no business logic.

02 ServicesOrchestration. Owns no persistence and no HTTP.

03 Unit of Work · gateThe transaction boundary. Nine repositories share one async session — a request commits or rolls back as one.

04 Job platformCelery and a Redis-backed store. Jobs are database rows, not fire-and-forget.

05 InferenceA provider registry. A second model is a registration, not a rewrite.

06 GeospatialPolygonisation, spectral indices and zonal statistics.

Decisions · 2 recorded, rejected options kept
DecisionOne session per request, shared by every repository
Context

Nine repositories each need database access inside a single request. If each opens its own session, a request that writes a project, a job and an audit log can half-succeed — leaving a job with no audit trail.

Options
  • A session per repository — No shared transaction boundary; partial writes become possible and invisible.

  • A session passed manually through every call — Works, but every new service has to remember to do it. A convention is not an invariant.

  • A Unit of Work that constructs the repositories — The boundary is structural — repositories cannot be built outside a transaction.

Decision

UnitOfWork is an async context manager. Entering it opens a session and constructs all nine repositories against it; leaving it rolls back on exception and always closes.

Consequence

Callers cannot accidentally write outside a transaction. The cost is that every repository must be listed in one place — an acceptable trade for making the invariant impossible to break.

DecisionA job is a database row, not a Celery result
Context

Segmentation over a satellite scene takes minutes. Celery returns a task id immediately and keeps the outcome in its result backend, which is a cache rather than a system of record.

Options
  • Use the Celery result backend as the source of truth — Restart the broker and every in-flight job disappears, with no record that it was ever submitted.

  • Write a row only once the job finishes — Leaves queued and running work invisible, which is exactly the window a user asks about.

  • Model the job as an entity with its own lifecycle, behind a store protocol — Queued, running, failed and complete stay distinguishable after a restart, and the store swaps for an in-memory one in tests.

Decision

Job is a table with a status enum, a type, a priority and separate submitted, started and completed timestamps. Persistence sits behind JobStoreProtocol, with in-memory and Redis implementations.

Consequence

Every dispatch costs a write before the work starts. In exchange the lifecycle is queryable, the audit log has a real foreign key to point at, and the job platform can be tested with no broker running.

Agents · Local-first · 2026 · Local-first voice agent · dashboard and automation layer

Stealth F.R.I.D.A.Y

A voice agent that runs entirely on your own machine, with a real-time dashboard streaming its state over WebSocket and an automation layer that lets it act on the system.

Status

Runs locally. Four commits, so the repository shows the result rather than the process, and the agent core is a shared codebase rather than mine.

Ownership

Shared project. The agent core is a codebase I worked from, not one I wrote; it also exists in Soumyadeb Tripathy's Raptor-AI repository. Mine is the layer around it: the Next.js dashboard and its WebSocket hook, the three API routes, the automation engine tools, the external automation modules, and the Windows port.

  • Python 3.11
  • Next.js 15
  • TypeScript
  • WebSocket
  • Faster-Whisper
  • OpenWakeWord
  • Groq · LLaMA 3.1
  • pyttsx3
  • Chrome extension
The problem

A voice assistant that ships every utterance to a cloud API is a privacy decision disguised as an architecture decision. Running the whole pipeline locally — wake word, transcription, planning, execution, speech — removes that, but replaces it with a harder problem: a long-running local process has no interface, so when it misbehaves there is nothing to look at.

The invariant

The agent's live state — what it heard, which module is active, whether it is listening, thinking or speaking — is observable from outside the process at all times.

The approach

The agent core runs a local pipeline: an always-on wake-word listener, Faster-Whisper for transcription on-device, a rule-based planner with an LLM fallback through Groq, a tool executor, and offline text-to-speech. My work sits around that core. A WebSocket bridge publishes agent state as it changes; a Next.js dashboard subscribes through a single typed hook and renders the live agent state, last command, active module and system health. An automation layer adds browser, network and system tools the executor can dispatch to, and the whole thing was ported from macOS launch agents to Windows.

Path through the system
  1. 01Agent core

    Shared, not mine. Wake listener, planner, executor and the WebSocket bridge.

  2. 02State bridgeGate

    Every message is a full snapshot, never a delta.

  3. 03Dashboard

    Mine. Live state, last command, active module and health.

  4. 04Control API

    Mine. Start the agent, read its status, mint a session token.

  5. 05Automation tools

    Mine. Browser, network and system tools in the dispatch table.

Architecture
  1. 06Dashboard

    Mine. Live agent state, last command, active module and health, over a single typed socket hook.

    • frontend/src/hooks/useRaptorSocket.ts
    • frontend/src/components/RaptorVisualizer.tsx
    • frontend/src/components/StateIndicator.tsx
  2. 07Control API

    Mine. Next.js route handlers to start the agent, read its status and mint a session token.

    • frontend/src/app/api/raptor/start/route.ts
    • frontend/src/app/api/raptor/status/route.ts
  3. 08Automation engine

    Mine. Browser, network and system tools the executor dispatches to.

    • core/tools/automation_engine/browser_tool.py
    • core/tools/automation_engine/network_tool.py
    • core/tools/automation_engine/system_tool.py
  4. 09External modules

    Mine. Standalone utilities — network scanning, system inspection, GitHub statistics.

    • external_modules/automation_script/nmap_network_scanner.py
    • external_modules/automation_script/system_info.py
  5. 10Agent core

    Shared, not mine. Wake listener, planner, executor, learning engine and the WebSocket bridge I publish through.

    • voice_agent_core/core/planner.py
    • voice_agent_core/core/executor.py
    • voice_agent_core/core/ws_bridge.py
The hard part

Making a long-running local process observable

The agent is a Python process with no natural interface, and the dashboard is a React app that can be opened, closed and reopened at any moment. The connection therefore cannot be the source of truth — a client that connects halfway through a command must still render the correct state. The socket hook owns reconnection with backoff and treats every inbound message as a full state snapshot rather than a delta, so a client that missed messages converges as soon as the next one arrives. The alternative — replaying an event log on connect — would have meant the agent keeping history it otherwise has no reason to store.

What is wrong with it

The repository has four commits, so it shows the result rather than the process. The agent core is a shared codebase, not mine — see the ownership note, which is stated on the page rather than buried here.

System complete04 / 06

Plate 04Where shared ends and mine begins

The whole systemThe outline is the claim. Dashed and amber is a shared codebase; solid is what I built around it.

01 Agent coreShared, not mine. Wake listener, planner, executor and the WebSocket bridge.

02 State bridge · gateEvery message is a full snapshot, never a delta.

03 DashboardMine. Live state, last command, active module and health.

04 Control APIMine. Start the agent, read its status, mint a session token.

05 Automation toolsMine. Browser, network and system tools in the dispatch table.

Plate 04Where shared ends and mine begins

The whole systemThe outline is the claim. Dashed and amber is a shared codebase; solid is what I built around it.

01 Agent coreShared, not mine. Wake listener, planner, executor and the WebSocket bridge.

02 State bridge · gateEvery message is a full snapshot, never a delta.

03 DashboardMine. Live state, last command, active module and health.

04 Control APIMine. Start the agent, read its status, mint a session token.

05 Automation toolsMine. Browser, network and system tools in the dispatch table.

Decisions · 1 recorded, rejected options kept
DecisionEvery socket message is a full snapshot, not a delta
Context

The dashboard can be opened at any point in the agent's life, and a dropped connection means missed messages.

Options
  • Send deltas — A client that missed one message is permanently wrong, with no way to detect it.

  • Replay an event log on connect — Forces the agent to retain history it has no other reason to keep.

  • Send the whole state on every change — Any client converges on the next message, whenever it arrives.

Decision

The bridge publishes a complete state object; the hook replaces rather than merges.

Consequence

Slightly larger messages, at a rate a human generates. In exchange, reconnection needs no special case at all.

Android · Reliability · 2026 · Android health and medication tracking

HealthTrack

A reminder that fires late is a reminder that failed. Built so scheduling survives reboots, timezone shifts and clock changes.

Status

Builds and runs. There is no test source set, which for an app whose argument is reliability is the first thing worth fixing.

Ownership

Sole author. All 7 commits.

  • Kotlin
  • Jetpack Compose
  • MVVM
  • Hilt
  • Room
  • DataStore
  • WorkManager
  • AlarmManager
  • Health Connect SDK
  • Firebase Auth
  • Firestore
  • BiometricPrompt
The problem

A medication reminder is not a notification feature. If the phone reboots, the user changes timezone, or the system clock is adjusted, every pending alarm on Android is silently discarded. The app that treats reminders as UI state loses them, and the user does not find out until the dose is missed.

The invariant

Every reminder the user has set exists in exactly one known state at all times, and that state survives the operating system deciding to forget it.

The approach

The app is split strictly into data, domain and presentation, with repository interfaces declared in the domain layer and implemented in data — and explicit mappers between Room entities and domain models, so persistence details never leak upward. Reminder state is a state machine in the domain layer rather than a set of booleans on a view model. Exact timing goes through AlarmManager; everything durable around it — rescheduling after boot, reconciling with Firestore, fetching config — runs as WorkManager jobs, which the OS is obliged to complete. Room is the source of truth, and Firestore workers reconcile it across devices rather than owning it.

Path through the system
  1. 01Presentation

    Compose screens and view models. No scheduling logic, no persistence.

  2. 02Domain

    Use cases and the reminder state machine. No Android imports at all.

  3. 03SchedulingGate

    Receivers enqueue; they never do the work. The OS is obliged to finish what WorkManager started.

  4. 04Data

    Room is the source of truth. Firestore workers reconcile it; they never own it.

  5. 05After a reboot

    Android discards every pending alarm. The worker recomputes the full schedule rather than diffing against a belief that is no longer true.

Architecture
  1. 06Presentation

    Compose screens and view models. Holds no scheduling logic and no persistence.

    • presentation/analytics/AnalyticsViewModel.kt
    • presentation/auth/BiometricLockScreen.kt
  2. 07Domain

    Use cases, models, repository interfaces and the reminder state machine. No Android imports.

    • domain/statemachine/ReminderStateMachine.kt
    • domain/usecase/ReminderUseCases.kt
    • domain/repository/ReminderRepository.kt
  3. 08Scheduling

    Exact alarms, boot and clock-change receivers, and the idempotent rescheduling worker.

    • data/scheduler/AlarmSchedulerImpl.kt
    • data/receiver/BootReceiver.kt
    • data/worker/RescheduleRemindersWorker.kt
  4. 09Data

    Room as source of truth, Firestore sync workers, Health Connect, and entity/domain mappers.

    • data/local/HealthTrackDatabase.kt
    • data/repository/FirestoreSyncRepository.kt
    • data/health/HealthConnectManager.kt
The hard part

Rebuilding a schedule the OS threw away

Android clears all pending alarms on reboot, and offers no callback for a timezone or clock change beyond a broadcast you must register for. Three receivers listen — boot completed, time changed, timezone changed — and each enqueues the same rescheduling worker rather than doing the work inline, because a broadcast receiver has seconds to live and rescheduling dozens of alarms against the database does not fit in that window. The worker is idempotent: it recomputes the full schedule from Room rather than trying to diff against what it thinks is pending, because after a reboot that belief is exactly the thing that is no longer true.

What is wrong with it

There is no test source set. For an app whose entire argument is reliability, that is the first thing worth fixing and the first question an interviewer should ask. The commit history is also a single day of bulk commits, so it shows the result rather than the process.

System complete05 / 06

Plate 05What a reboot does to a schedule

The whole systemFour layers that only ever call downwards, and under them the reason they exist: the alarms after the line are the ones the OS threw away.

01 PresentationCompose screens and view models. No scheduling logic, no persistence.

02 DomainUse cases and the reminder state machine. No Android imports at all.

03 Scheduling · gateReceivers enqueue; they never do the work. The OS is obliged to finish what WorkManager started.

04 DataRoom is the source of truth. Firestore workers reconcile it; they never own it.

05 After a rebootAndroid discards every pending alarm. The worker recomputes the full schedule rather than diffing against a belief that is no longer true.

Plate 05What a reboot does to a schedule

The whole systemFour layers that only ever call downwards, and under them the reason they exist: the alarms after the line are the ones the OS threw away.

01 PresentationCompose screens and view models. No scheduling logic, no persistence.

02 DomainUse cases and the reminder state machine. No Android imports at all.

03 Scheduling · gateReceivers enqueue; they never do the work. The OS is obliged to finish what WorkManager started.

04 DataRoom is the source of truth. Firestore workers reconcile it; they never own it.

05 After a rebootAndroid discards every pending alarm. The worker recomputes the full schedule rather than diffing against a belief that is no longer true.

Decisions · 2 recorded, rejected options kept
DecisionReceivers enqueue work; they never do it
Context

BOOT_COMPLETED and TIME_CHANGED arrive as broadcasts. A receiver has a few seconds before the system may kill it, and rescheduling every reminder means reading the database and calling AlarmManager repeatedly.

Options
  • Reschedule inline in the receiver — Exceeds the broadcast window on a cold boot with many reminders; work is killed halfway.

  • Start a foreground service — Heavier than the task needs, and shows the user a notification for housekeeping.

  • Enqueue a WorkManager job — The OS guarantees it runs, retries it, and survives process death.

Decision

Each receiver does exactly one thing: enqueue RescheduleRemindersWorker.

Consequence

Rescheduling is slightly delayed after boot but is guaranteed to complete. The worker is written to be idempotent so a retry is harmless.

DecisionReminder state as a machine, not as flags
Context

A reminder is scheduled, then fired, then acted on or missed — and can be edited or deleted at any point in that sequence.

Options
  • Boolean flags on the entity — Permits impossible combinations, e.g. fired and not-yet-scheduled at once.

  • An enum with transitions checked at call sites — Every new call site is a new chance to skip the check.

  • An explicit state machine in the domain layer — Invalid transitions cannot be expressed.

Decision

ReminderStateMachine owns every transition; nothing else writes status.

Consequence

Adding a state means editing one file. The UI and the workers both ask the same object what is legal.

Full-stack · Team · 2026 · Surplus food redistribution · team project

EcoShare

Eight commits inside a four-person codebase: the surplus-food endpoints, the model and validators, the dashboard integration and the deploy config.

Status

Deployed on Vercel and publicly reachable — the only project here that is. A four-person build; eight of fifty commits are mine.

Ownership

Team project, 8 of 50 commits. The listing endpoints, Food model, validators, dashboard integration and deploy config are mine; the application as a whole is not.

  • TypeScript
  • Express
  • MongoDB
  • React
  • JWT
  • Vercel
The problem

University kitchens throw away food that NGOs and students would take, and the gap is logistical rather than moral — surplus appears with a few hours of usable life, and whoever can collect it needs to know before it expires. The system has to model a listing that is time-bounded and claimable exactly once.

The invariant

A food listing can be reserved by exactly one party. Two NGOs must never both be told they have it.

The approach

This was a four-person build and my part was the server side of the listing flow. I wrote the food controller across five commits, the Food model with its shared types and request validators, and the NGO and kitchen paths through it — then the dashboard integration and the frontend API service that consumes it, and the Vercel routing config that got it deployed. It is the only project here where I worked inside someone else's codebase, which is the reason it is on the site at all.

Path through the system
  1. 01Kitchen

    Surplus appears with a few hours of usable life.

  2. 02Listing

    Mine. The Food model, its shared types and the request validators.

  3. 03ReservationGate

    The invariant. A listing can be claimed by exactly one party — two NGOs must never both be told they have it.

  4. 04NGO

    Mine. The dashboard and the frontend API service that consumes it.

  5. 05Deployed

    Mine. The SPA routing config that got the frontend live.

Architecture
  1. 06Food controller

    Mine. Listing, reservation and the NGO/kitchen paths, across five commits.

    • backend/src/controllers/foodController.ts
    • backend/src/routes/foodRoutes.ts
  2. 07Model and validation

    Mine. The Food model, shared types and request validators.

    • backend/src/models/Food.ts
    • backend/src/types/food.ts
    • backend/src/validators/foodValidator.ts
  3. 08Dashboard

    Mine. The dashboard page and the frontend API service layer.

    • frontend/src/pages/Dashboard.tsx
    • frontend/src/services/api.ts
  4. 09Deployment

    Mine. SPA routing config that got the frontend live.

    • frontend/vercel.json
The hard part

Working to someone else's conventions

The interesting difficulty was not technical. The repository already had a shape — a controller layout, a validation approach, a response format — and the right move was to match it rather than improve it, because a codebase with two competing conventions is worse than one with a convention I would not have chosen. Where I did want a change, it was smaller and easier to justify: extracting request validation into a validator module rather than checking fields inline, which the rest of the team then used.

What is wrong with it

One of my commits added eight ad-hoc debugging scripts to the repository root that should have been cleaned up before pushing, and my commit messages here are well below the standard I set on TerraMind. Both are visible in the history and neither is defensible.

System complete06 / 06

Plate 06One listing, exactly one claim

The whole systemSupply arrives at the top. At the gate, one organisation is told yes and the other is told no. The marked parts are the ones I wrote.

01 KitchenSurplus appears with a few hours of usable life.

02 ListingMine. The Food model, its shared types and the request validators.

03 Reservation · gateThe invariant. A listing can be claimed by exactly one party — two NGOs must never both be told they have it.

04 NGOMine. The dashboard and the frontend API service that consumes it.

05 DeployedMine. The SPA routing config that got the frontend live.

Plate 06One listing, exactly one claim

The whole systemSupply arrives at the top. At the gate, one organisation is told yes and the other is told no. The marked parts are the ones I wrote.

01 KitchenSurplus appears with a few hours of usable life.

02 ListingMine. The Food model, its shared types and the request validators.

03 Reservation · gateThe invariant. A listing can be claimed by exactly one party — two NGOs must never both be told they have it.

04 NGOMine. The dashboard and the frontend API service that consumes it.

05 DeployedMine. The SPA routing config that got the frontend live.

Decisions · 1 recorded, rejected options kept
DecisionValidation as a module, not inline field checks
Context

Request validation was being written inline in each controller, so the same shape was checked slightly differently in two places.

Options
  • Leave it inline and match the existing style — The divergence was already producing different error responses for the same bad input.

  • Introduce a validation library — A dependency decision is not mine to make unilaterally on a shared codebase.

  • Extract a plain validator module — No new dependency, matches the existing structure, and the team adopted it.

Decision

foodValidator.ts holds the shape checks; controllers call it and return one error format.

Consequence

One place to change when the model changes. The smallest change that fixed the actual problem.

Method

Four principles, each with the artifact that proves it. These are not aspirations — every one is visible in a commit history someone else can read, and one of them is about recording the results that went against me.

  1. Draw the boundary before you need it

    Repositories behind a unit of work, models behind a registry, renderers behind an adapter, a language model behind an evidence bundle it cannot write back through. Not to be clever — because the second implementation always arrives, and by then the code that assumed there would only ever be one is load-bearing.

  2. Write the specification first

    Nine architecture volumes preceded TerraMind's globe engine, committed as their own baseline before a line of it existed. PratiBimb went further: a frozen constitution, twenty-five security invariants and a threat model were merged before the first product package. It is slower for a day and considerably faster after that.

  3. Degrade, don't fail

    A subtree that renders its own failure beats a white page. A reminder that rebuilds its own schedule after a reboot beats one that quietly disappears. An answer with no model attached beats a feature that needs an API key to do anything at all. The interesting engineering is almost always in what happens when something goes wrong — and the honest version of this principle is that TerraMind has the weakest claim to it of the three, which is why its entry here is an error boundary rather than something grander.

  4. Record the result that goes against you

    PratiBimb's test vehicle turned out to be blind to the send path it was supposed to be watching — a suite that would have passed while proving nothing. It was merged with the failing verdict attached, the quality gate was marked unsignable, and the blocker went on the repository's front page. A log a stranger cannot reconstruct the reasoning from is not finished, and one that only records the wins is worse than none.

Reading the code

One real file from TerraMind, with the reasoning attached. Nothing here is simplified for the page — the line numbers are the file's own, and the link goes to the same lines.

apps/backend/src/unit_of_work.pyPython · TerraMind AI
Annotated source of the Unit of Work implementation
LineSourceNote
18class UnitOfWork:
27 async def __aenter__(self) -> "UnitOfWork":An async context manager, so the transaction boundary is the language's rather than a convention someone has to remember.
28 self.session = self.session_factory()
31 self.users = UserRepository(self.session)Every repository is constructed here, against the same session. There is no way to obtain one outside the boundary.
32 self.projects = ProjectRepository(self.session)
36 self.jobs = JobRepository(self.session)
39 self.audit_logs = AuditLogRepository(self.session)Nine in total. A request that writes a project, a job and an audit log commits all three or none.
49 if self.session:
50 if exc_type is not None:Exit rolls back on any exception and always closes — the caller cannot leak a session by forgetting.
51 await self.rollback()
52 await self.session.close()

Instruments

61 entries, and every one links to the file that proves it. Nothing appears here that isn't in code I wrote, and every link is requested on each build.

TerraMind
30
EcoBites
2
EcoShare
2
HealthTrack
9
F.R.I.D.A.Y
2
Cartograph
7
PratiBimb
9

Backend

07

Architecture

06

Geospatial & ML

08

Frontend

07

Mobile

07

Rendering & interaction

04

Rust & static analysis

06

Privacy & on-device ML

06

Quality & delivery

10

Traverse

Dated from commit history. The elevation bands encode the step up in complexity at each station, not how much time passed between them.

Elevation is the step up in complexity at each station · spaced by order, not by date
  1. Aug 2024First commitGitHub account opened. Start of the public record.
  2. Nov 2024A static pageCARCRAFTERS — HTML, CSS and vanilla JavaScript. Worth keeping in the record because the distance from here is the point.
  3. Apr 2026First architected systemHealthTrack. The jump from pages to architecture: Clean Architecture, Hilt, Room, WorkManager, Health Connect, 174 files.
  4. May 2026Working inside a running systemStealth F.R.I.D.A.Y — a live dashboard and automation layer built around an existing local agent core.
  5. Jul 2026A codebase with other people in itEcoShare, deployed. Then the same domain rebuilt alone in Spring Boot, and the IBM Node.js and Express certification.
  6. Jul 2026TerraMind AIFive days and 90 commits to the first cut, sole author; 122 now, with ruff, mypy and pytest gating every push since August. Specification-first and phase-tracked.
  7. Aug 2026This siteBuilt in public. Its own source is linked in the colophon, and the build fails if a number here loses its sample.
  8. Aug–Sep 2026CartographSix milestones inside a Rust architecture engine someone else started: the desktop app, blast radius, structural diff, the GitHub reviewer, the MCP server and the AI boundary. The first codebase where the review was as much of the work as the code.
  9. Sep 2026PratiBimbSmart India Hackathon, ISRO problem statement 26171. A two-person team with a frozen constitution, twenty-five security invariants and a spike protocol that pre-registers its accept criteria — including the one that invalidated our own test plan.
  10. Oct–Nov 2026A prototype that runs, and says how farPratiBimb through milestone M21: the extension, a local reasoner on loopback and the execution gate, end to end on one machine and measured there. Still synthetic pages only, still an unadopted visual detector — and the repository says both on its front page.

Contact

Open to internship and new-grad software engineering roles.

All systems documented6 systems · 28 readings · 47 ground samples

I'm looking for backend, systems or platform work.

If you're building something where the infrastructure between a model and a user is the interesting part — or where somebody has to decide what the system is allowed to know — that's the conversation I want.

Write to meronitsaha.edu@gmail.com