Cheri Hewlett · Technology & innovation executive · Builder · CPA · Veteran

AI takes thewhat and the how.Leadership isthe why and the who.

I draw the bridge from problem to solution through technology — starting with the problems worth solving: the ones that return quantifiable value, and deliver real impact. Then the right solution for each. Not the newest thing — the thing that pays.

I don’t build theory — I build from market friction, and I build it myself. The figures below are not typed in. They are recomputed from the engineering record every time this page builds, and labelled by how much you should trust them.

  • 6,912changes written personallythe output of a small engineering team
  • 1,721pieces of work shippedeach one reviewed before it went live
  • 302reusable building blocksso the next project starts ahead
  • 4systems running in productionnot prototypes

Any one of these is common. Two together makes a strong hire. All four in one person is the profile these roles are written for — and rarely find.

claimsourcestate
  • 0production systems, designed and built hands-ongit · four private repositoriesreading git log
  • 0authored commits across four production systemsgit · excludes bot and merge commitsreading git log
  • 0pull requests written, reviewed and mergedGitHub APIreading git log
  • 0edge functions running in productiongit · supabase/functionsreading git log
  • 0database migrations under governancegit · supabase/migrationsreading git log
  • 20 yrsleading enterprise software, most of it in the office of the CFOcareer · not machine-checkablereading git log

Verified figures are recomputed from the engineering record each time this page builds. Attested figures are career facts no script can check, and are labelled rather than dressed up as measurements.

The fourinnovation · engineering · domain depth · leadership

Turning a problem into a solution that returns value takes four things at once: the domain to see the real problem, the judgment to choose the one worth solving, the engineering to build the answer, and the leadership to carry it to impact. Most candidates bring two. Here is each, with what backs it.

Problemworth solvingImpactvalue returnedDomainSeethe real problemJudgmentChoosethe one worth solvingEngineeringBuildthe answerLeadershipLeadit to impact

Domain depth

Finance, accounting, and the systems that run them

CPA · MS Accounting · PwC and Deloitte · audit, close, consolidation, migration, change

Financial close and consolidation, system migrations and go-lives, and the operating-model change around them — the work where a wrong number is a reportable event, not a bad suggestion. I turned that expertise into a library of rules that each cite their own source, so any answer can be checked back to the standard it came from.

Most technology leaders have to borrow this depth. I have lived it.

Product

Zero to one, then to scale

Platform line from concept to market with full P&L ownership

Product, engineering, sales and customer success under one owner, carried commercially. I have also sat in the other seats — implementing, selling and supporting the product, which is why I know where plans meet reality.

Most engineers have never carried a P&L.

Engineering

Hands-on, in production

Self-taught in agent architectures, MCP, and Supabase

Four systems designed and written personally, start to finish, and running against real financial data rather than sitting in a demo folder. I am not one step removed from how the thing actually works.

Most executives commission the build and summarise it.

Leadership

People first, always

U.S. Air Force — mission first, people always

Rose from customer success manager to senior executive leadership. Organizations don’t outperform because they obsess over customers; they outperform because they invest in the people serving them.

Most builders optimise the system and forget who has to run it.

That combination is the whole argument. Everything else on this page is evidence for it.

Point of viewjudgment · resilience · builder

Innovation is choosing the right problem

Most companies are solving the wrong problems faster. AI didn’t fix that — it accelerated it. The first question is never “can we build this,” it is “is this the problem that deserves the next six months, and is it the one to solve first?”

ROI is the problem solved, not the time saved

Time doesn’t disappear; it gets reallocated. The real question is what caliber of quality the team operates at after the investment. This is not about working less — it is about operating differently, and smarter.

Trust is the real moat

Everyone is asking “can AI do this?” The better question is “can we prove it did it right?” In the office of the CFO that is not a nice-to-have — it is the difference between a system people adopt and one they quietly work around.

How you treat people is the strategy

Organizations don’t outperform because they obsess over customers. They outperform because they invest in the people serving them. As AI absorbs more of the execution, that becomes more of the job, not less.

“The leaders who thrive in this next decade won’t simply be fluent in technology. They’ll be deeply human.”

What's runningfour production systems

These are private repositories, so the code stays where it is. What is published here are counts — recomputed on every build, never hand-maintained, and never estimated when a system cannot be read.

Team Echo

Multi-agent operating system with persistent memory, governed tool use, and self-verifying status.

3,469 changes131 live services259 database changes1,021 shipped changes26 automated tests11 safety checks
Jan 2025 — Jul 2026

Innovation Hub

Portfolio cockpit for prototype due diligence, roadmap prioritization, and team time allocation.

1,681 changes530 shipped changes49 automated tests
Jan 2025 — Jul 2026

Consolidation Platform

Financial consolidation and close engine built on the accounting doctrine corpus.

1,607 changes117 shipped changes29 automated tests
Jan 2025 — Jul 2026

Accounting Doctrine KB

Atomic US GAAP and IFRS rules with SOX-grade citability and auditor re-verifiability.

155 changes53 shipped changes3 automated tests
Apr 2026 — Jul 2026

See it worknot a description — a live artifact

Most of the work proves itself in numbers. This part proves itself by running. Type a request — or pick one — and watch the guardrail decide. It refuses first and classifies second, which is the whole design decision.

Runs entirely in your browser — deterministic, no model call, nothing stored or executed. The same shape as the real guardrail: it refuses first, and classifies second.

Backgroundwhere the domain came from

The differentiator

Every seat in the product lifecycle

Customer success, solutions consulting, product and business transformation, platform strategy. I don’t just understand the product — I understand what it feels like to implement it, sell it, support it, and bet a company’s transformation on it. Most innovation leaders talk theory. I’ve lived inside these systems, rebuilt them, and lead from that.

The spine

Air Force. Big Four. Founder. Investor. Operator.

Served in the U.S. Air Force — mission first, people always. PwC and Deloitte. Founded my own CPA firm serving real estate investors and small businesses. Built and managed a rental portfolio over a decade. Strategic advisor to Crux (London) on product-acquisition integration, and a board member of the G.R.O.W. Foundation. Rose from customer success manager to senior executive leadership at a publicly traded fintech. Every chapter required learning something new from zero.

How I build

Problem-led, from market friction

I quantify friction and build solutions to problems others haven’t identified yet — demand-driven, not theory-driven. Strategy anchors direction, execution is in my DNA, and agility runs through both. The model plans; deterministic code decides; nothing closes on the builder’s own say-so.

Cheri Hewlett speaking on stage
Two decades finding the gaps that matter — and the last two years building the systems that close them.

CPA (VA) · M.S. Accounting, Liberty University · B.S. Accounting & Computer Science, University of Maryland · U.S. Air Force Veteran · Strategic Advisor, Crux (London) · Board Member, G.R.O.W. Foundation · Los Angeles, CA

Speaking & writingon stage, in print, on the record

Signature talks

In a World Where Technology Is Changing Everything Else

AI is taking on more of the what and the how. So what’s left for leaders? Everything that actually matters.

Innovation Is Choosing the Right Problem

Most companies are solving the wrong problems faster. AI didn’t fix that — it accelerated it.

Trust Is the Real Moat in AI

Everyone’s asking “can AI do this?” The better question: “can we prove it did it right?”

People First: The True Responsibility of Leadership

Organizations don’t outperform because they obsess over customers. They outperform because they invest in the people serving them.

Built, Not Born: What Resilience Actually Requires

Resilience isn’t a personality trait. It’s a practice — built by surviving, rebuilding, and choosing to show up again.

The Chapters You Don’t Put on Your Résumé

Your most important career chapter is probably the one you’re embarrassed to talk about.

Recent stages

  • 2026Building with Agentic AI: A Fintech Leader’s Show & TellProduct Advisory Collective
  • 2024BlackLine Investor DayNew York
  • 2024SAP SapphireBarcelona
  • 2024LWT SummitLeading Women in Technology
  • 2022 — 2026BeyondTheBlackMain stage, five consecutive years

Writing

Recorded & featured

Contactdirect

Open to conversations about platform, product, and AI leadership roles.

LinkedIn ↗X · @cheripromo ↗Résumé, plain text ↗This site's source ↗

Everything above is the summary.

What follows is the detail — how the systems are built and run. Useful if you want to check the work, and safe to skip if you already have what you need.

Arsenalbuild once, reference everywhere

302reusable capabilities
catalogued and maintained

Built once, referenced everywhere. Every capability carries an ID, an owner, and the list of projects consuming it — so the next build pulls instead of rebuilding. 252 are production-ready today; the rest are registered the moment work starts on them, so nobody duplicates one by accident.

PAT

Architecture patterns

122

Reusable engines and scaffolds — routing, consolidation, audit trail, memory lifecycle

CMP

Components

40

Code modules built once and pulled across projects

LSN

Lessons

32

Durable failure patterns, recorded so they are not repeated

FRM

Frameworks

32

Process and decision methodologies — gates, protocols, review models

SKL

Agent skills

26

Defined capabilities an agent can invoke by name

RES

Research

22

Architecture, design, and market findings kept as evidence

TPL

Templates

20

Reusable documents, prompts, and executive communications

DSN

Design systems

8

UI systems, dashboard standards, visual templates

Built once, reusable elsewhere

Consolidation Platform

AI entity matching and schema mapping

Reconciling messy source structures against a target model. The same machinery applies to any migration, integration, or master-data problem.

Consolidation Platform

Deterministic engine under model orchestration

The model chooses mapping and sequencing; the arithmetic is deterministic code with a traceable path. This is the pattern that makes AI usable where a wrong number is reportable.

Accounting Doctrine KB

Citable, re-verifiable retrieval

Atomic rules carrying their own citations, so an answer can be walked back to source by someone who does not trust the model. Portable to law, clinical, and policy domains.

Consolidation Platform

Enterprise connector and activation layer

Source-system connectors, import recognition, and SSO activation — the unglamorous surface area that decides whether enterprise software actually lands.

How it worksrequest lifecycle

The ordering here is the design decision. Most agent stacks classify a request first and check safety afterwards — by then the model has already reasoned about it. This one refuses first.

blocked · logged · no model callRequestany surfaceGuardrailfails closedClassifierintent + domainRegistry routerno hardcoded mapTool authorityeffective policyMemory writetagged, filterable

The agent org35 agents · 16 teams · 46 scheduled jobs

Not a pile of scripts on timers. A registry of agents with tiers, named duties, and escalation paths — every figure below read from the live registry and scheduler rather than from a document describing them.

  • 35agents registered
  • 16teams
  • 46scheduled jobs
  • 21active in production

How work escalates

  1. Signalwebhook · heartbeat · mailbox · self-test
  2. Routerclassify, dedupe, assign
  3. Triage L1resolve or escalate
  4. Analyst L2diagnose, scope, own
  5. SystemsSRE · integrations · governance
  6. CTObuild, review, merge

Nothing in that path waits on someone noticing. An item that ages past its threshold raises its own severity and escalates itself.

The teams

Orchestrator
One router in front of thirteen specialists
Systems
Reliability, integrations, and platform governance
Helpdesk
Tiered triage with SLA escalation at 3, 7, and 14 days
Core Operations
Briefing, email, execution, relationships, analysis
Memory & Learning
Write pipeline, recall scoring, weekly consolidation
Branding & Presence
Publication pipeline and opportunity synthesis
Career & Employment
Role pipeline and professional network
Infrastructure
Universal contract, memory writer, workspace integrity

What runs unattended

every 15 min
System health, credential probes, SLA escalation
every 30 min
Operations grooming and run-failure scanning
hourly
Brand pipeline sweep, systems-team runtimes, approval dispatch
daily
Briefing, signal sync, issue routing, triage sweep, plan verification, session distillation
weekly
Governance deep scan, memory evaluation, growth and performance rollups, reflection, domain deepening

Enablementsignal to implementation

The same five stages whether the subject is an infrastructure fault, an account drifting toward churn, or an implementation running late. Deterministic rules and domain logic do the deciding; the model handles the ambiguous middle. Each stage below is marked for whether it is running today or is where the existing machinery extends.

  1. Source the signals

    running today

    One intake for everything the business emits — vendor webhooks, heartbeats, self-tests, mailbox alerts, quality gates, user reports. Signals normalise into a single shape and deduplicate against what is already open, so a repeating fault increments a count instead of spawning forty tickets.

    Eight source classes, five signal types, one open signal per source-system-type.

  2. Let severity find itself

    running today

    A signal that keeps recurring, or stays open across a long first-to-last span, re-triages itself one severity level up without anyone re-reading it. Ageing work escalates on a fixed ladder rather than waiting to be noticed.

    Auto re-escalation at five repeats or a twenty-four hour span; three, seven and fourteen day SLA ladder.

  3. Anticipate the gap

    where it extends

    The same intake reads leading indicators rather than faults: usage decay against an account baseline, milestone slippage against a plan, engagement thinning ahead of renewal, attainment drifting from target. The judgement is deterministic rules and domain logic first, with the model reserved for the ambiguous middle.

    The pattern the intake and severity machinery already implement, pointed at commercial and delivery signals.

  4. Turn it into owned work

    running today

    Detection that ends in a dashboard is detection that gets ignored. Every raised signal becomes a routed item with an owner and acceptance criteria attached, and completion is gated on authenticated proof from outside the agent rather than the agent reporting itself done.

    HMAC-verified webhook completion with acceptance-proof detection before anything is marked closed.

  5. Implement, system-agnostic

    where it extends

    Enterprise implementation is mostly deterministic work wearing a bespoke costume: recognise the source data, map it to a target model, apply the domain rules, validate, activate access. Built once for financial consolidation, the stack is not specific to it — the model proposes mappings and sequencing, deterministic rules decide, and domain knowledge supplies the constraints.

    Import recognition, AI mapping and matching, connector layer, and SSO activation, already running against a live target system.

Practiceimplementation detail

The work below is the kind that usually gets compressed into one line of an executive résumé. It is here in full because it is the part that is hard to fake.

Registry-driven agent routing

Replaced a hardcoded specialist map with a routing table sourced from live agent registry records — keyword activation, context mapping, and classifier-domain composition resolved at runtime. Adding an agent is a row, not a deploy.

Fail-closed authority boundaries

Tool and action authority load as effective policy and are enforced at call time. When policy cannot be resolved, the action is refused rather than allowed — the failure mode is a stopped agent, never an ungoverned one.

Guardrails ahead of classification

Request guardrails run before model classification, so destructive and unsafe requests are refused without a model call, and every violation writes telemetry that can be audited later.

Adversarial safety coverage

Deterministic red-team suites across destructive actions, financial actions, impersonation, credential requests, and sensitive data — paired with true-negative checks so the classifier is measured on over-refusal too.

Truthful status verification

A verifier recomputes completion state from live checks instead of trusting recorded status. It detects pass-to-fail regressions, flags claim-versus-check drift, and raises an alert when a status is asserted that the evidence no longer supports.

Authenticated completion gating

HMAC-verified webhook processing with acceptance-proof detection, so work is marked complete only when something outside the agent confirms it happened.

Prototype → scalethe whole arc

Product and innovation leadership is written as a lifecycle — prototype, prove, harden, scale. The common gap is a leader who has lived in one or two of those stages. Here is what sits at each.

  1. Prototype

    Rapid prototyping, design thinking, minimum viable tests.

    Working prototypes stood up in hours, not sprints — the reason four systems exist at all rather than four decks describing them.

  2. Prove

    Stage-gate progression with evidence-based go and kill decisions.

    Phase gates that refuse to advance on assertion: every item states what was verified and how, and nothing advances at medium confidence. Innovation Hub exists to run exactly this triage across a portfolio of prototypes.

  3. Harden

    Production readiness, quality, and operational ownership.

    Migrations under governance, adversarial safety suites, CI gates that block on drift, and completion gated on authenticated proof rather than self-report.

  4. Scale

    Commercial launch, platform consolidation, global enterprise rollout.

    Enterprise connectors, SSO activation, and multi-system rollout — carried commercially, including finding product-market fit across a global enterprise base and consolidating fragmented lines into one platform.