All services
Advisory

Platform architecture consulting

The decisions that are expensive to reverse โ€” stack, data model, boundaries โ€” made before the code that depends on them exists.

Pricefrom $800

How this one runs

Category
consulting
Starts with
A free 30-minute scoping call
Engagement
Fixed price, milestone, retainer or fractional
After launch
Thirty days of fixes included
Reply time
Within one business day

About this service

Delivered as Postgres, Firestore, and Architecture work, under the constraint every product in this catalogue is built under: it has to run without a paid service in the critical path, without a server that must be kept alive, and without a vendor whose pricing can move under you. That began as a budget decision and became a design one.

Scope is agreed on a call before anything is quoted, and what the work does not include is written down at the same time as what it does. If this is the wrong service for your problem, that is a sentence you get on the call rather than a discovery in week three.

How this one goes

What the work actually looks like

Which database. What a user is. Whether identity is yours or a provider's. Whether a tenant is a column or a schema.

None of those looks like a decision at the time. Each one looks like getting started.

They are made in the first week and they are expensive to reverse in every week after it.

A year later they are load-bearing, nobody wrote down why, and the person who would have known has moved on.

That is the problem. It shows up as a team that has stopped being able to say yes to things, and as a roadmap where every item quietly costs more than the last.

Most people who ask for this can describe the symptom precisely and cannot name the cause. Estimates that keep growing. A change in one place that breaks something in another.

A new hire who takes months to become useful, because the reasoning lives in a conversation nobody recorded.

The constraint on this service is that the advice has to be usable by people who are not me.

A recommendation only I can carry out is not advice; it is a dependency with a document attached.

So the output is written down in language a team can argue with, and the reasoning comes with it so a future reader can decide it was wrong. That is the point of it.

The second constraint is the catalogue's rather than this service's. A recommendation does not get to assume a paid service in the critical path, or a server somebody has to keep alive, unless that cost is named, priced and agreed first.

The third is about honesty rather than technology. A review can always return a longer list of problems than the system actually has. So the record names what should stay as clearly as what should change, and that section gets written first.

What an engagement of this shape produces is a document rather than a deployment.

Stack selection with the trade-offs written down, including the ones arguing against the choice I recommend. A data model and access-pattern review, which is mostly reading the queries rather than the schema, because the queries are what the schema is for.

Cost modelling against real usage, built from your own numbers so you can run it again after they move. A migration path from what exists today, whose intermediate states each have to work on their own. And a written record a future team can argue with.

The findings live in the queries. A schema is a guess about the future; the queries are what actually happened, and reading them in order explains a cost line better than any diagram.

The cost model is the deliverable people expect least and use most. It is a spreadsheet you keep, not a slide I present, and its inputs are the read counts, row counts and request volumes your product already produces.

Migration paths get the same treatment. Each step is written so the work can stop after it, which is the difference between a plan and an ambition.

My name is Ahsan Mahmood, and the reason the record is written to be argued with is that I will not be in the room when it matters.

The costs are honest, and there are four.

One is that the written record takes time that ships no feature, and it is the deliverable most likely to be cut when a week gets tight. Cutting it removes the only part that outlives me.

Another is that the recommendation is often to change less than you expected. A rewrite is a recommendation I have to earn, not a default, and a review ending in keep this, fix these four things and move on is a review that has just reduced its own scope.

A migration path is also slower than a rewrite. Every intermediate state has to work in production while people are using it, which is exactly why the path finishes and the rewrite sometimes does not.

The fourth is yours rather than mine. Advice nobody acts on is worse than no advice, because it becomes a document people cite to explain why nothing changed.

What this service does not do is take the decision for you. I can put the trade-offs in writing, model the cost and name the path, and the choice stays with whoever has to live with it.

Implementation afterwards is a separate engagement, quoted separately. Turning it down changes nothing about the record you already hold.

The rest of the exclusions are the catalogue's. Visual design as a standalone deliverable. Native iOS. Blockchain work. Copywriting and content.

One more belongs here.

I will not tell you your architecture is fine when it is not, and I will not tell you it is broken because a rewrite would be more interesting to build.

What is included

Five deliverables, every time this service is bought. Anything outside this list is quoted separately rather than assumed.

  • 01Stack selection with the trade-offs written down
  • 02Data model and access-pattern review
  • 03Cost modelling against real usage
  • 04Migration path from what exists today
  • 05A written record a future team can argue with

Technologies and tools

The default set for this service. A project with a good reason to differ gets that reason written down before we start.

  • Postgres
  • Firestore
  • Architecture

Questions

Common questions

The questions that actually arrive, answered in the first sentence.

Can you review or take over a codebase somebody else wrote?
Yes, and it starts with an audit rather than a feature. You get a written read on code quality, security and performance, and a prioritised list โ€” which includes the parts I would leave alone. A rewrite is a recommendation I have to earn, not a default.
What do I actually receive at the end?
A written record: the stack decision with its trade-offs, a data-model and access-pattern review, a cost model built from your own usage numbers, and a migration path from what exists today. It is written for a team to argue with rather than for me to present. Nothing in it needs me to be the person who carries it out.
How is the cost model built?
From your own numbers rather than from a benchmark, which is what makes it something you can run again after those numbers change. Read counts, row counts and request volumes are the inputs, set against the pricing of whichever options are being compared. That is also why it stays useful once the engagement ends.
What if the answer is to change nothing?
Then that is the answer, written down with the reasoning attached. A rewrite is a recommendation I have to earn, not a default. A review ending in keep this and fix four things has just reduced its own scope, and that is the right outcome more often than it is a disappointing one.
What does an architecture review cost?
The number comes from scope, integrations and timeline โ€” and you get it in writing after the scoping call, never before it. I do not quote from a brief alone, because the quotes that come from briefs alone are the ones that get revised upward later. How much of the system is in scope is the first thing that call settles, since a review of one boundary is a different piece of work from a review of a whole platform.

Why choose this

Four commitments that hold for this service the same way they hold for the other eight.

Built the way it will be maintained

Typed end to end, structured so a second developer can find things, and commented where the reasoning is not obvious from the code. You are not buying a codebase only I can read.

The failure paths are designed, not discovered

Empty, loading, offline and error states are built with the feature rather than after it, because those are what a real user meets on a first run or a bad connection.

You see it running every week

A working demo against the milestone, not a status update. If something slipped you hear it that week, while there is still time to change what we do about it.

Handed over completely

Repository, store listings and documentation are yours. Nothing needed to run or rebuild the product stays on my machine, and nothing is licensed back to you.

Ready to start?

Tell me what you are building and roughly when you need it. The first call is thirty minutes, costs nothing, and ends with either a scope or an honest reason not to proceed.

Related services

Frequently bought alongside this one, or a better fit if this is not quite it.