Skip to content

Process design · Project planning · Specification

Most IT projects don't fail while they are built. They fail before anyone agreed what was actually needed.

We start with how the work happens in your company today, design the process that should replace it, and write it down precisely enough to be built from — by your own people or a contractor you choose. We are not that contractor, and that is the point: nothing in the plan is there to keep us busy.

  • The plan is the deliverable — yours, in full, to take anywhere
  • No stake in the delivery, so no reason to specify more than you need
  • Process before software: often the answer is less of it, not more
  • Written so a third party can quote it and be held to it

What we do

Six disciplines, all of them upstream of the code.

Each one starts with the same question: what is this costing you today? The technology is a consequence of the answer, never the starting point.

  • Process analysis

    Before the software question, the work question.

    What actually happens today: who touches it, in what order, where it waits, and what people quietly work around. Written up as a map you can correct — because a good part of every requirements list turns out to be a workaround nobody has questioned yet.

  • Process design

    The way of working that should replace it.

    The target process, decided with the people who will have to live in it: what stays manual on purpose, what becomes a rule, what disappears. This step regularly removes more scope than it adds. The cheapest system is the one you no longer need.

  • Solution architecture

    The shape of the system, settled before anyone writes code.

    What the system owns, where the data lives, who may see what, how a release happens and how a recovery happens. Each decision recorded with the alternative it beat and the trade-off it accepted, in language that still makes sense without us in the room.

  • Requirements & specification

    Precise enough to be built from, and to be measured against.

    Functional requirements, the non-functional ones everyone forgets, interfaces, data, and acceptance criteria attached to each requirement. The document a competent team can turn into working software without having to guess what you meant.

  • Vendor selection & tendering

    So the offers you get back are actually comparable.

    Tender documents drawn from the specification, evaluation criteria agreed before the first pitch, and a technical review of what arrives. We do not bid, and we take nothing from whoever wins — our only interest is that you choose well.

  • Project governance

    A project you can steer instead of watch.

    Phases, decision points, quality gates, and acceptance against the specification. Progress becomes something you can verify rather than something you are told, and problems surface while they are still cheap to fix.

The projects we plan

  • Custom software
  • Digital infrastructure
  • Websites & web presence
  • Integrations & automation
  • Data & reporting
  • Operations & support

What we hold to

Seven commitments. Each one is checkable.

Values are only worth stating if a client could hold you to them. These are written so you can — and so you know what to ask us about.

Independence

We have nothing to sell you at the end.

Our work finishes with a plan, not with an invoice for carrying it out. That single fact sits behind every recommendation in it: no incentive to specify a bigger system, a longer timeline, or a technology that happens to suit us. When we tell you a requirement isn't worth the money, nothing of ours depends on you disagreeing.

Ownership

The plan is yours, in full.

Process map, architecture decisions, specification, acceptance criteria — handed over as documents you own and can give to anyone. Nothing is written in a notation only we read, and nothing is held back so that the next step has to run through us.

Right-sized

The simplest thing that solves the problem. Sometimes that is nothing.

Most systems fail from too much rather than too little: a platform bought to solve a spreadsheet problem, a microservice architecture for four users. Where the honest answer is a changed process and no new software, we will say so — and that answer costs you a planning fee instead of a project.

Security by construction

Decided in the architecture, not patched on afterwards.

Least privilege, minimal attack surface, no third party without a reason, no data collected because it might be useful later. Security added at the end is a patch; security decided in the architecture is a property of the system. This website follows the same rule — no tracking, no external requests, nothing to leak.

Plain language

If we can't explain it simply, we don't understand it yet.

You will always know what is being proposed, what it should cost, and which trade-off was accepted on your behalf. No jargon used to sound expert, no architecture diagram deployed to end a conversation. A specification that impresses you without informing you has failed at its only job.

Longevity

We plan for year five, not for launch week.

A demo can be specified in a week. A system that survives staff changes, audits, load and five years of small modifications is a different discipline, and that is where the money actually goes. We plan for the second one — and we say plainly which parts of it you are safe to postpone.

Accountability

Measured in what changes, not in documents delivered.

A specification is not a result. We agree upfront what should be different once this exists — fewer manual steps, a quote that goes out the same day, an error that stops happening — and we stay with the project until it is accepted against exactly that. A plan nobody could execute is our failure, not yours.

How a project runs

Four steps, and you can see into all of them.

No phase where you have to trust that things are going well. Each step ends with a document you can read, check and disagree with.

The shape a specification aims at: rules in one place, one source of truth, and operations designed in from the start rather than discovered afterwards.

  1. Understand

    We follow the work, not the org chart: what happens today, who touches it, how long each step waits, and which parts exist only to compensate for another part. Nothing is proposed at this stage. The goal is a description you read and recognise as your own company.

    A written map of how the work runs today, precise enough for you to correct.

  2. Decide

    Then the decisions, in the open: which process replaces the current one, what the system must own, where data lives, who may reach it, and what deliberately stays out of scope. Every choice is recorded together with the alternative it beat, so it can be revisited later without archaeology.

    The target process and the shape of the system, with every trade-off named.

  3. Specify

    The decisions become a document someone else can work from: requirements, interfaces, data, acceptance criteria, and answers to the questions a bidder would otherwise raise three weeks in. If you intend to tender, this is what goes out.

    A specification precise enough to quote against, and a realistic cost range.

  4. Accompany

    While it is being implemented we stay on your side of the table: checking what arrives against the specification, keeping the decision log current, and naming drift early rather than at the deadline. The people doing the work are yours or your contractor's; the standard they are held to is the one you agreed.

    Acceptance against the plan, instead of against whatever happened to arrive.

Technology we specify in

Deliberately boring choices.

The vocabulary a specification is written in is deliberately mainstream, because that is what keeps your options open: easier to hire for, easier to hand to a different contractor, and still supported in five years. And where a choice can stay open, it stays open — the document states what has to be true, not which product to buy.

Application

  • TypeScript
  • React
  • Next.js
  • Node.js
  • Python

Data

  • PostgreSQL
  • Redis
  • SQLite
  • S3-compatible storage

Infrastructure

  • Linux
  • Docker
  • Terraform
  • Nginx
  • Cloudflare

Operations

  • Git
  • CI/CD pipelines
  • Monitoring & alerting
  • Automated backups

About

How we work

Synix Solutions is a small team that plans and specifies IT projects. We stop deliberately before implementation: the moment one company also sells you the delivery, every estimate, every requirement and every technology choice carries an interest that is not yours. Keeping those two apart is the whole value of the arrangement.

We take on work we can be accountable for. If a project needs a capability we don't have, we say so — hearing that from us is cheaper for you than paying us to learn it.

What we won't do

  • Take on the delivery of a system we specified.
  • Accept a commission or referral fee from whoever ends up delivering it.
  • Specify something we know you don't need because it was on the request list.
  • Write a specification that only its author can interpret.
  • Promise a date we don't believe in to win the work.

Questions

The things people ask before the first call.

Answered here so you don't have to book a meeting to find out.

You plan it — so who builds it?

Your own people, or a contractor you choose. The specification is written so that decision stays yours, and so competing offers can be compared line by line. We don't bid for that work ourselves, and we take nothing from whoever gets it.

Why not hire one company to plan and deliver?

You can, and for small, well-understood work it is often the pragmatic choice. On anything larger it means the party estimating the work also profits from the estimate being generous, and the party defining “done” is the one being measured against it. Separating the two costs a planning fee and buys you a standard that is independent of the delivery.

What do we actually get at the end?

A map of the current process, the target process, the architecture decisions with their trade-offs, and a specification with acceptance criteria per requirement. If you are tendering: the documents to send out and the criteria to judge the answers by. All of it yours, in formats you can edit.

What does it cost, and how long does it take?

Planning is a fraction of an implementation budget, and it gets scoped like any other work: the first conversation is free and ends either with a fixed-scope proposal including a price, or with an honest statement that we're not the right fit. Small, well-defined work runs in weeks. Replacing an established process takes months, mostly because deciding is slower than writing.

We already have systems. Do they have to be replaced?

Usually not, and replacing them is rarely the cheapest answer. More often the work is to connect what exists and remove the manual copying between the parts. Where something genuinely has to go, we will say so — and where it doesn't, we will say that too, even though a replacement would make for a larger project.

How do we start?

Send an email describing the situation in your own words. No brief or specification needed — producing those is the job. You will get either questions back or a suggested time to talk.

Get in touch

Tell us what isn't working.

No brief required, no sales call. Describe the situation in a few sentences and you'll hear whether a plan is what you need — and if it isn't, we'll say so rather than write one.

No contact form, on purpose — a form would mean collecting your data on a server. Email leaves it with you. The address is in the footer.