What Amphare is

Amphare Technologies builds governed, AI-native software delivery.

The method is atomikd: scope is decomposed into machine-checkable units, each with a contract and an evidence grade, scheduled in waves and shipped inside a release envelope.

The kernel is AmphSE: it sits above the coding agents and enforces the gates.

The instrument is CodeSentinel: it reads the code and grades the evidence.

The map is RepoGraph: the code graph every atom is planned against. The proof is a services pod that delivers real client software with all three and feeds what it learns back into the product.

The hybrid is deliberate. Service work funds the product and tests it against reality. The product makes the service faster, and lets us show a client exactly what was built, how it was verified, and by whom. Showing the client that is the business.

Why this role exists

Someone has to hold the whole project: the client's actual problem, the architecture that answers it, the estimate the business signed, the waves that get it built, and the evidence that proves it shipped. In a traditional firm that is a project manager, an architect, a scrum master and a BA, plus a steering committee. Here it is you, with three solid colleagues and a kernel that enforces the gates you set.

You are the person a client trusts because you can draw the system on one page and defend every box. You are the person the pod trusts because when the critical path is blocked, you open the editor.

What you own

- The engagement. One at a time for the first pod. From sales handover to acceptance: scope, commercial envelope (what the fixed price can absorb), risk, client relationship, and the decision to say no when the evidence says no. Pricing new work and signing contracts stay with the founder.

- Solution shape. Architecture, stack choice for the client's constraints (we are stack-agnostic by principle), integration boundaries, non-functional requirements,



and the trade-offs written down where the client can read them. You are accountable for the user experience too; specialist design is engaged per engagement from outside the pod.
- The Epic Map and the estimate.

Decomposition to the level where effort can be measured and compared with what we actually spent. Your estimates are checked against outcomes every wave. Wave scheduling and the release envelope. What ships, in what order, with what dependencies, under what gate.

Short, written, evidence-first.

- Pod governance. The gates agents and humans pass through, the evidence grades we accept, the retros that change the method. "AI proposes, humans approve" is a rule you enforce, including on yourself.
- The pod itself. Growing the three people beside you, and writing down how this pod works so the next pod can copy it.

Who we are looking for

- You have shipped production software as an engineer and later run delivery for teams larger than this pod, and you know what that cost.
- You have personally fixed a bad estimate, in front of a client, with numbers rather than apologies.
- You can draw a system on one page and answer "why not the obvious alternative" for every component.
- You have read code an agent wrote for you closely enough to send it back. More than once.
- You have written requirements, test plans and release notes yourself because nobody else was going to, and they were good.
- You can name a ceremony you removed from a team and what you replaced it with.
- You are commercially literate: blended rates, margin, fixed-price risk, what a change request costs.

Signals this is not your role

- You manage through status meetings and feel exposed without a PMO.
- You last committed code three or more years ago and are comfortable with that.
- You believe "architect" means not touching the keyboard.
- You see AI coding tools as a productivity add-on for juniors.
- You cannot do your best work until scope is frozen.
- You prefer to be told the method rather than to improve it.

📌 Pod Lead, Delivery Architect (Kolkata)
🏢 Amphare
📍 Kolkata