FIT: turning an agency’s judgment into software

Level 343 is a marketing strategy agency I’ve subcontracted with for years. Like every good consultancy, their real product isn’t deliverables. It’s judgment: which actions a client should take, in what order, and why. And like every consultancy, that judgment lived in the heads of strategists and a sprawl of spreadsheets, rebuilt from scratch for every client engagement.

The ask: could that methodology become a system? Not a generic project tracker, which exists and doesn’t help, but software that thinks the way the agency thinks, so every client engagement starts from the firm’s accumulated judgment instead of a blank sheet.

This was a partnership from the start. Level 343’s in-house strategist knew the methodology cold; she authored the functional requirements and the scoring formulas, the actual mathematics of “what should this client do next.” My job was translation: turning that expertise into a product that thinks the way she does, a functional and secure application a whole team could use without her in the room.

The interesting challenge in that translation wasn’t technical. It was epistemological: how do you encode expert judgment without pretending the software knows better than the expert?

The answer became the product’s operating principle, written into its interface: FIT suggests, the strategist decides.

Every recommendation the system makes is transparent and overridable. The tool’s job is the bookkeeping a human strategist shouldn’t waste judgment on (scoring consistency, dependency tracking, capacity math), surfaced in a form that makes the human’s decision faster and better defended.

The division of labor, plainly: the methodology came from the agency. What gets scored, how the formulas weigh it, what the phases mean. The product was my job: the architecture, the data model, how it works, feels, and holds together securely.

A scoring engine. Every proposed action gets a FIT score derived from impact and effort, plotted onto a quadrant matrix (quick wins, big bets, fill-ins, reconsider), so a client’s entire possible portfolio is legible at a glance, with a ranked priority queue beneath it.

Dependency logic with urgency inheritance. Actions block and unlock each other, and the system reasons about it: a prerequisite in the chain of an urgent action inherits that urgency, with the reasoning shown on the card. Blocked work is visually ringed on the matrix and flagged in alerts. This is the feature that makes the tool strategic rather than decorative. It catches the “we prioritized the flashy thing whose prerequisite nobody scheduled” failure that burns real engagements.

Planning at three altitudes. A 90-day roadmap for execution scheduling, with budget envelopes and per-person capacity tracking that alerts on overallocation, so a strategist at 125% gets flagged before the plan fails, not after. A 6-month strategy view that explains why work is grouped into phases, scored by a weighted Strategy Health index across alignment, coverage, confidence, and feasibility. And a portfolio action list: the one canonical record, where every edit updates the same data everywhere.

A canonical data layer. Objectives, SMART goals, metrics, risks, assumptions, constraints, stakeholders, workstreams: entered once in a central Data Center, feeding every screen. No copy-paste drift between the roadmap and the strategy doc, ever again.

Client-ready output. Multi-client from the ground up, with role-based access, CSV export, and print/PDF reporting, because a consultancy’s tool has to produce the artifact that goes in front of the client.

The stack. Full-stack TypeScript, end to end: a Node backend with Argon2 authentication, a React frontend built on Vite with TanStack Query for server state and React Router, and Zod validation guarding the data layer.

I built FIT the way modern solo products get built: AI-directed development under human architecture. The specifications, data model, interface behavior, architectural decisions, security auditing, and QA against spec were mine; the implementation code was AI-generated under my direction and review. One person shipped what would recently have required a team, which is, fittingly, the same philosophy the product itself runs on. The tool does the labor; the human owns the judgment.

FIT is deployed and in client testing at Level 343. The roadmap includes the obvious evolution: an AI-assisted layer for drafting action sets and first-pass scoring from discovery inputs. Suggestions only, because the operating principle doesn’t change. FIT suggests. The strategist decides.

My whole career pattern is in this build. A client relationship where I was trusted enough to sit with the firm’s actual methodology and the strategist who wrote it. Discovery work to understand how she really makes decisions: not how the process doc describes it, how she does it. Product design to give that thinking a shape a whole team can use. And the AI-native development practice to ship the application solo, on a modern stack, with the architecture, security, and quality bar held by hand.

I’ve spent years as the person agencies hand things to when the brief crosses disciplines. This is what that looks like when the discipline being crossed is the distance between an expert’s head and working software.