Consulting · SaaS & Payments

Senior engineering, on retainer.

Direct access to a senior engineer who has shipped production payments and SaaS infrastructure. Used when you need a deep, second pair of eyes on the system you are about to build — or already have in flight.

How to engage
Engagement 01

Architecture review

A fixed-scope deep read of an existing system or a planned build. Code, schema, payment flows, data model, the concurrency story, the failure modes. Closes with a written assessment and a concrete roadmap.

  • Two-week engagement, mostly async with two scheduled deep-dives
  • Written assessment, ranked findings, and a recommended sequencing
  • Closes with a 90-minute walkthrough with your team
Engagement 02

Advisory retainer

A monthly block of senior engineering time used the way you need it — design reviews, code reviews, an extra brain on a hard call, hiring help, an outside read on a vendor pitch. Async by default, with scheduled calls when they help.

  • Monthly hours block — used flexibly through the month
  • Shared channel (Slack or similar) for between-call questions
  • Month-to-month, paused or stopped on a month's notice
Scope

What I tend to look at.

Most engagements end up touching some subset of these areas. Yours might be one of them, half of them, or something adjacent — we'll figure that out on the intake call.

API design

Versioning, contract stability, idempotency at the boundary. How the API holds up as your callers grow in number and stop reading the changelog.

Data modeling

Schemas, state machines, audit trails. Modeling business workflows as explicit transitions so on-call and compliance can both answer their questions from one table.

Concurrency safety

Locking, transactions, race conditions. Where two writers can step on each other, where they can't, and where the database actually guarantees what you think it does.

Background work

Job queues, retry semantics, failure-mode design. What gets retried, what gets dead-lettered, what wakes someone up.

Observability

Logs, metrics, traces in production paths. Where the system can go silent and what to instrument so it can't.

Database transaction boundaries

Where to commit, where to roll back, what to snapshot at decision points so reports stay correct months later.

Webhook handling

Delivery vs idempotent processing as separate concerns. Why the provider's API is the source of truth and the webhook is just a hint to go ask.

Migration safety

Running schema changes on live data without downtime. The patterns that break under load and the ones that don't.

Rhythm

What working together looks like.

The default is async — calls are scheduled when they help, not imposed as a daily standup. The aim is to be available without becoming a meeting tax.

  • ·Async by default.Most of the work happens on your repo, in a shared channel, and on review docs. Live time is reserved for the moments where it actually accelerates the call.
  • ·Shared channel for between-call questions.Slack, Discord, or whatever your team uses. Same-business-day response on weekdays — never "always on," but never absent either.
  • ·Output lives in a shared doc.Architecture review deliverable, retainer log of work done — both end up in a written document you and your team can revisit. Nothing lives only in someone's head.
  • ·Cadence you can plan around.One weekly check-in by default; deep-dives scheduled as the work demands. Calendar is your call — I work across timezones from West Africa, comfortable with most overlap windows.
Process
01

Intake call

A 30-minute call to understand what you're building, where it hurts, and whether either of these engagement shapes fits. No deck, no sales pitch.

02

Scoped proposal

Within a few days I send a one-page proposal with the scope, the deliverables, and the price. Plain language, no surprises.

03

Start

On signature and the first payment, work starts on the date we agreed. Most engagements kick off within a week.

Common questions

Does this convert into a full build if we want one?

Yes. If the review or the retainer surfaces work you want my agency, SaaS Simplified, to take on, we scope a build engagement separately. The advisory work and the build are billed separately — never an upsell pressure inside the consulting hours.

Do you sign NDAs?

Yes. Send yours and I'll review it; if you don't have one I have a short mutual NDA I can share.

How fast can we start?

Architecture reviews kick off within about a week of signature. Retainers can start the same week if the scope is straightforward.

How many engagements at once?

A small number, deliberately. Usually one architecture review concurrent with one or two retainers — never more. If I'm at capacity I'll say so up front and offer a start date.

Async-only, or some calls?

Both, depending on the engagement. Architecture reviews include two scheduled deep-dives plus the written work. Retainers run mostly async with calls scheduled when the work needs them.

What if our scope is too small for a review?

Then the retainer is likely the better fit — same access, less commitment. We figure that out on the intake call. There's no minimum scope you have to manufacture to engage.

Start the conversation

Tell me about the system you're working on.

A short email is enough — the architecture, where you're stuck, and how soon you want a second read. I reply within one business day.