Consulting · How the work actually runs

The software is the easy half. Choosing well, moving people without losing them, and handing it over so you can run it — that is the work.

Assessment from 3 days · engineering 110 EUR an hour · no VAT added · scope before price, always

Read the estate as it really is.

Read what you run as it really is, not as the contract describes it. It is the only piece that sometimes ends with "stay where you are".

Most of this work starts as a question rather than a project. Somebody asked where the data actually is and nobody knew. A contract renews in March. The bill went up again and the usage did not.

An assessment answers that in writing. What you run, what it costs once the labour is counted, which obligations actually apply and which are merely assumed, and what would genuinely improve if any of it moved.

It is deliberately a small, fixed piece of work. It has to be cheap enough to commission before anyone is committed to an outcome, or it stops being an assessment and becomes a proposal.

What gets read

Every system in daily use, what it costs and what it is contractually tied to
Where the data physically sits, in fact rather than in the terms
Which obligations apply to you, and which of those are currently met
The directory, and how joiners and leavers are actually handled
What already broke, and what was done about it
Who inside the organisation would own a replacement, and what hours they have

What comes back

A current-state note with the awkward findings named rather than softened
Three-year cost both ways, with the labour counted on both sides
A written recommendation, including "stay where you are" where that is right
A risk register, in the order the risks would actually bite
The parts we would leave exactly where they are, and why
A scope for the next stage, if there is going to be one

Not included: an assessment shaped by what we would be paid to build next. If the answer is the product you already have, that is the answer and the invoice is the same.

Design, and the record of why.

Every choice that is expensive to reverse gets written down before it is made.

A design is a set of decisions, and most of them are cheap now and expensive in two years. Which engine, which topology, where identity lives, what federates with what, and the order things move in.

Each one is written down with the options that lost and the reason they lost. That record is worth more than the diagram: a year later somebody will ask why, and "it seemed right at the time" is not an answer an organisation can act on.

What is decided

Which engine, and honestly why not the other one
Topology and sizing against traffic you actually have
Identity model, and what happens to an account when a person leaves
What reaches outside, what does not, and who approves a change to that
Retention, and the technical thing that enforces it
The migration route, including the pilot group and the rollback

What is written

Architecture, in language somebody who is not an engineer can check
A decision record per choice, with the rejected options kept
A data map: what is held where, and who can reach it
The obligations this design meets, and the ones it does not
A staged plan with the awkward stage named rather than buried

Not included: a design that survives contact with your environment untouched. It will change; what matters is that the change is recorded rather than absorbed.

Build it so it can be rebuilt.

Installed in staging and rebuilt from files, so nothing important lives in a memory.

Everything is installed in staging first and defined in files, so the whole deployment can be rebuilt rather than remembered. That is the difference between an estate and a pet.

One upgrade is rehearsed before anything goes near production, because the first upgrade is where most self-hosted estates die.

How it is built

Configuration under version control, reviewable by your own engineers
Staging that mirrors production closely enough to be worth having
Hardened defaults, and every deviation from them recorded with its reason
Backups configured, and one restore actually performed and timed
Monitoring and alerting in place before the first person is invited

What you can check

Read the configuration; it is files, not a console someone clicked through
Run the restore yourself and time it
Ask for the deviation list and read the reasons
Rebuild staging from scratch and see that it comes back the same

Not included: a deployment that only we can maintain. If the only copy of how it was built is in our heads, we have sold you a dependency.

Move people without losing them.

People move in groups with the old system still running, so the switch is a fade.

Migration takes longer than installation and it is where trust in the whole idea is won or lost. A pilot group first, always, and the old system still running until it is genuinely not needed.

The old contract is cancelled on purpose, with notice, after the new thing has carried real work for a while. Not on the day the new thing turns on.

How the move runs

A pilot group chosen for being ordinary, not for being enthusiastic
Both systems live, so a person can go back the same afternoon
History carried across where it must be, and left where it need not
Groups move on a stated schedule, with the schedule published to them
A rollback that has been tested, not one that exists in a document

What people get

One page telling them what changes and what does not
The new thing already carrying something they need, not an empty room
A named person to ask, inside their own organisation
Their account made for them, not a registration form
A week where both work, so nobody is cornered

Not included: a migration that nobody notices. People notice. What can be arranged is that they notice once, briefly, and know it was coming.

The six months after the install.

The six months after the install decide whether the install was worth anything.

An estate nobody watches is an estate nobody can defend. Alerts that fire before people notice, backups that have been restored, upgrades rehearsed somewhere safe.

This is the least visible part of the work and the only part that is not optional.

Watching

Metrics and dashboards that answer a question rather than fill a screen
Alerts tied to written runbooks rather than to raw thresholds
Checks from outside your own network, so an outage is not invisible to you
Certificate expiry watched, so it is never a visitor who notices
Capacity trends, so growth is planned rather than discovered

Surviving

Backups with a stated recovery point and recovery time
Off-site copies, encrypted, with the key held by you
A restore performed and timed, then written down
Maintenance windows with the work stated in advance
An honest note after an incident, including the ones that were our fault

Not included: a 24-hour rota. Response times are counted in working hours, as stated in clause 6 of the terms at /terms.

Handover is the deliverable.

You should be able to replace us. The documentation is the proof that you can, and it is the deliverable rather than the risk.

The point of building on open standards is that you are not obliged to keep anyone, us included. That is only true if the handover actually happened.

So it is a stage with its own deliverables rather than a conversation at the end, and it is written for whoever inherits the system rather than for whoever built it.

What is handed over

Runbooks per component, written for the person on duty at 2 a.m.
A named owner for every component, agreed rather than assumed
Every setting that differs from the default, with the reason beside it
The configuration repository, and the right to it
Credentials, rotated at handover so ours stop working

Training that goes with it

Administrators and operators, on your own deployment
Developers, on the APIs they will actually touch
Everyone else, on the two habits that matter and none of the rest
Train-the-trainer material, so the organisation carries on without us
A review some months later, when the honeymoon is over

Not included: free labour. Handover is work and is charged as work — but nothing is charged for the act of leaving, ever.

An outside read of what you already run.

An outside read of something already running, with a written result and a price.

Plenty of estates work and nobody can say why, which is the same as nobody being able to say when they will stop.

A review is bounded work with a written result: what is exposed, what is stale, what breaks next, and what it would take to fix each one.

What is looked at

Exposure: what answers the internet, and what should not
Authentication, rate limits and how secrets are held
Components past end of life, and the upgrade path off them
Backups: whether a restore has ever actually been run
Drift between what is documented and what is deployed
An inventory of everything nobody owns any more

What comes back

Findings in the order they would actually bite
Effort and impact stated per item, so triage is possible
The things that are fine, said plainly, so the list is trustworthy
A remediation roadmap you can hand to somebody else to execute

Not included: a pass or fail certificate. A review reports findings. Certification is a separate regime with separate auditors.

Procurement, before it is written badly.

The wording of a tender decides who can answer it. That is worth an afternoon.

A requirement written around one product gets one kind of answer. A requirement written around an outcome gets a comparable set.

This is a small piece of work with a large effect, and it is usually cheaper than the first month of the wrong contract.

What we write with you

Requirement text stated as outcomes rather than as features
Evaluation criteria with weights agreed before the answers arrive
The questions that separate a real answer from a brochure
What a good migration plan looks like, so you can recognise one
Exit terms, written while you still have leverage

What we will tell you

Where an open standard is genuinely the wrong answer for you
Which of your requirements is quietly ruling out most of the market
What the incumbent will say, and which part of it is true
What a realistic timeline is, against the one in the paper

Not included: writing a tender that only we can win. If the requirement text points at one supplier, it is a bad requirement text.

Training on your own system.

Training on your own deployment, not on a slide deck about somebody else's.

Training on a generic environment teaches a generic environment. Sessions run on your deployment, with your names in it, against the things your people will actually be asked to do.

The measure of it is whether the organisation can carry on without us, which is why the material is left behind rather than presented.

Who is trained

Operators: the daily jobs, and the ones that only happen when it breaks
Administrators: accounts, policy, and the things that cannot be undone
Moderators, where a platform has them, on the tools and on the policy
Developers: the APIs, the extension points, and the conformance tests
Everyone else: the two habits that matter, and nothing else

What is left behind

Recordings and slides, yours to reuse
A handbook written against your deployment, not a generic one
Exercises somebody new can work through unattended
Train-the-trainer notes, so the next cohort does not need us

Training covers the systems and operating procedures agreed in the scope.

start

Start with what is forcing the question.

The useful first message is not "we want to self-host". It is what you run today, what it costs, what renews and when, how many people it has to serve, and what obligation or deadline is driving the question.
You get back an assessment of whether moving is worth it, what it would cost over three years counting the labour, and a plain note on the parts we would leave exactly where they are.

Write to: hello@ave17.com
About: Consulting

Not included: a fixed quote from a first message. An assessment is a piece of work and it is priced as one.

The six stages, and what lands at the end of each.

The first stage often ends with a recommendation not to proceed, and that is a successful outcome rather than a failed sale.

Stage	What happens	What comes out
Ask	One conversation to establish the requirement, the constraints and who decides.	A short written answer on whether this is worth doing at all.
Assess	Read the estate as it really is: systems, contracts, data location, obligations.	A current-state note with the awkward findings named, not softened.
Design	Choose the engines, the sizing, the identity model and the order things move in.	Architecture and a decision record, including what was rejected and why.
Build	Install and integrate in staging, with configuration under version control.	A running estate, versioned, and one upgrade already rehearsed.
Move	People migrate in groups, with the old system still there until it is not needed.	Production in use, rollback still available, the old contract cancelled on purpose.
Hand over	Train whoever will run it, and write down how it runs.	Runbooks, training, and a named owner for every component.

Not included: fixed duration. Stages are sequential, but their length depends on your estate and on how long your approvals take.

How we charge.

Three shapes, and which one applies is decided before the work starts rather than argued afterwards.

Fixed, for a bounded piece

An assessment, a review, a procurement pack. The scope is written down first, the price does not move, and if it turns out to be bigger than it looked we say so before doing the extra rather than after.

from 3 days at 110 EUR an hour, quoted against the scope.

By the hour, for engineering

Build, migration, development and anything that cannot honestly be bounded in advance. Time is recorded against the thing it was spent on and the record is yours to read.

110 EUR an hour, invoiced on completion.

Monthly, for keeping it running

Maintenance, monitoring, backups and support. Invoiced in advance, cancellable on a month, and it follows the deployment rather than the number of people in it.

From 39 EUR a month. The cost section at /consulting/E has the arithmetic.

Not included: charging by the number of people who use what we built. Cost follows the work and the infrastructure, never headcount.

When we say no.

Six situations where the honest answer is not to do this, and what to do instead. Any supplier who cannot name these is selling rather than advising.

You are two people

Below a handful of users the maintenance costs more than the subscription it replaces. Buy the product. Come back when the headcount or the obligation changes.

Better answer: a hosted service, and spend the saved effort elsewhere.

Nobody will own it

This fails when it is one enthusiast's side project. The failure is never technical; it is that the person leaves and the estate rots.

Better answer: do not start until an owner is named and has the hours.

You need one specific proprietary feature

If the work genuinely depends on a feature only one product has, no amount of principle replaces it.

Better answer: keep that one product, move everything around it.

The deadline is next month

Migration takes longer than installation, and rushing it is how people lose trust in the whole idea.

Better answer: renew once more, move deliberately, cancel with notice.

You are chasing a certification you do not have

Running software yourself does not confer compliance. It moves the responsibility onto you.

Better answer: understand the obligation first, then decide who should carry it.

It is only about money

Some of this is cheaper. Some is not, once the labour is counted honestly.

Better answer: ask for the three-year comparison with the hours included, and read the total.

Not included: an argument that the open option is always better. Frequently the product you already have is the right call, and we will say so in writing.

What an assessment actually contains.

So that it can be judged before it is commissioned, rather than after it lands.

What you run: Every system in daily use, what it costs, what it is tied to and when that tie next comes up for renewal.
Where the data is: In fact, not in the contract: which machine, which jurisdiction, and who else can reach it.
Which obligations bite: The ones that actually apply to you, separated from the ones that are assumed because a competitor mentions them.
Three-year cost, both ways: With the labour counted on both sides. The version without labour counted is the version that misleads.
A written recommendation: Including "stay where you are" where that is right, and the reasoning, so somebody who was not in the room can check it.
A scope for what follows: If there is going to be a next stage, it is described and priced here, not discovered later.

An assessment is deliberately small and fixed. It has to be cheap enough to commission before anyone is committed to an outcome, or it stops being an assessment.

Not included: a proposal dressed as an assessment. If every assessment we ever wrote recommended buying something from us, it would not be worth commissioning.

What it costs.

The running cost of an estate, moved around until it looks like yours. Nothing is sent anywhere; this runs in your browser and is an estimate, not a quote.

Where the machine stands	What it is	Per month
Your own hardware or cloud	you provide the machine	39 EUR / month
Ours · Small	2 cores, 4 GB, 40 GB	69 EUR / month
Ours · Medium	4 cores, 8 GB, 80 GB	119 EUR / month
Ours · Large	8 cores, 16 GB, 160 GB	199 EUR / month

Bolted on	Rate
Each bridge, bot or extra service	10 EUR each a month, up to 24

Support	What it is	Per month
Standard	included	included
Priority	199 EUR / month	199 EUR / month

Setup, once: 590 EUR
Engineering outside scope: 110 EUR an hour
An assessment: from 3 days at 110 EUR an hour
Above 1000 users: the ladder stops and we quote

No VAT is added: we are not registered for it, so the figure shown is the whole figure.

Setup is charged once; everything else is monthly. Engineering is 110 EUR an hour and is quoted separately, against a written scope.

Not included: the engineering. This is what it costs to keep running. Building it is quoted against the scope the assessment produced.

What we will not do.

The list is short and it is here rather than buried, because every item on it is something a supplier could be asked for and should refuse.

We will not

Recommend a build because we would be paid to do the building
Make a certification claim without supporting evidence
Promise availability outside the agreed terms
Write a tender that only we can win
Name you as a customer without written permission
Take a deployment away from another supplier without telling them

We cannot

Read the content of an end-to-end encrypted room. Nobody can, and an offer to do it is the warning sign
Make open software confer compliance on you; it moves the responsibility, it does not discharge it
Guarantee what a third-party component will do after its own authors change it
Guarantee what another supplier will release to you on exit
Give legal advice. We write the engineering documents your counsel reads

Where any of this changes, it changes on this page first and in a proposal second.

Not included: exceptions to this list for a large enough contract. That is the whole point of writing it down in public.

Who you are dealing with.

Who you are dealing with, and the paperwork that goes with it.

Company	AVE17 LTD, registered in England and Wales, number 17254143
Address	128 City Road, London, EC1V 2NX, United Kingdom
Data protection	Registered with the Information Commissioner's Office, reference ZC225076
Contact	hello@ave17.com
Engineering rate	110 EUR an hour. We are not registered for VAT, so none is added
Assessment	from 3 days at 110 EUR an hour, fixed against a written scope
Payment	Bank transfer or card. Invoices payable within 14 days
Notice	One month either way, no reason required and no exit fee of any kind

The terms of service, the privacy notice and the Article 28 data processing agreement are published on this site, before anyone is asked to sign anything.

Write to: hello@ave17.com
About: Consulting

Not included: legal advice. This states our own position; your obligations are yours to take advice on.

DevOps, and what the word covers here.

The word is here because it is what people search for, and it is a section rather than a service of its own because that is what it honestly is: a name for how the stages above are carried out.

What the word covers here

Configuration under version control and reviewable by your own engineers, so a deployment is rebuilt rather than remembered
Staging that mirrors production closely enough to be worth having, and one upgrade rehearsed in it before anything goes near production
Source, review, build and artefacts on infrastructure you hold: Forgejo with runners and Harbor, or GitLab Community Edition where its wider surface is genuinely needed
Metrics, logs and alerting in place before the first person is invited: Prometheus, Loki, Alertmanager and Grafana, with every alert written against a runbook rather than a raw threshold
Backups with a stated recovery point and recovery time, off-site and encrypted with a key you hold, and one restore actually performed and timed rather than scheduled
Releases, rollbacks and maintenance windows that have been run rather than described, with the work stated in advance
Crash reporting that stays inside your estate, on GlitchTip, which takes the client libraries your application is probably already using
Containers where a container is enough and a virtual machine where it is not, on Proxmox VE, with k3s only where a workload really does span machines

What it is not

DevOps covers the six stages above and the systems in the catalogue.
A tool we licence to you. Every system named here is third-party open source, listed in full with its upstream project, and its own licence travels with it
A rota. There is none, clause 7 of the terms makes no availability promise, and support is counted in working hours
A percentage of your cloud bill. The published ladder is the whole of it: the machine, the setup, the hour and the support level
Kubernetes by default. Most estates this size do not need it, and running one is a job somebody has to be paid for

We assess, deploy and operate infrastructure. The stages describe the work, the catalogue names the systems, and the price panels carry the figures.

Not included: a platform team on shift. This is a practice applied to your estate rather than a headcount we supply, and where the work genuinely needs engineers on a rota we are the wrong supplier and would say so before you bought anything.

What is agreed in time.

What the work is, what it costs and what we would refuse are above. This is when anything happens, with the clause each period comes from, so it can be read in the contract rather than taken from a service page.

Before anything starts: An order becomes a contract when we confirm it in writing, and anything said before that is an estimate. Setup begins once the first invoice is paid and you have provided what the deployment needs: a domain, access to the machine where it is yours, and any directory we are asked to join. Clause 4.
A support request, standard: 2 in 30 days, answered within 2 working days, included with the machine. Working hours, Monday to Friday, excluding public holidays: a request sent on Friday evening is answered on the next working day.
A support request, priority: 4 in 30 days, answered within 8 working hours, at 199 EUR a month. The same working hours. Anything past either allowance is charged at 110 EUR an hour.
An invoice: Payable within 14 days. Setup once before the work begins, maintenance monthly in advance, and work outside the agreed scope quoted before it starts and invoiced when it is done. Clause 5.
A price change: At least 30 days before it applies to you, and never to a month already invoiced. Clause 5.
A change to these documents: At least 30 days before a material change applies, and you may end the contract before it takes effect. The date a version came into force is printed on the document, with every earlier date listed under it. Clause 14.
Notice to stop: 1 month in writing, either way. No reason is required and there is no exit fee of any kind. Clause 13.
A breach: Either side may end it at once where the other commits a material breach and has not fixed it within 14 days of being told. Clause 13.
Your data after you stop: Personal data we hold for you as processor is deleted within 30 days of termination, sooner if you ask, unless the law requires us to keep it. Clause 13.
Cancelling as a consumer: Where you ordered as an individual rather than as an organisation, 14 days from the day the contract is made, and the refund within 14 days of your telling us, less the value of any work you asked us to begin inside the window. Clauses 4 and 5a.

Start and delivery dates are agreed in the written scope before the first invoice. Support is counted in working hours under clause 6 of the terms.

Delivery dates are agreed in the written scope for your project.

If it does not suit.

Panel C says when we would turn the work down. This is the other direction: what happens when you turn us down, or when what arrived is not what was agreed.

If the answer is not to proceed: An assessment that ends in stay where you are is a finished piece of work, and the invoice is the same as one that ends in a build. That is the outcome we are paid for rather than the outcome we prefer, and it is why the assessment is priced small enough to commission before anyone is committed.
If the work is not what was agreed: Where you ordered as a consumer the Consumer Rights Act 2015 requires it to be carried out with reasonable care and skill and lets you require the work to be done again, or the price reduced; no contract can take that away and clause 5a says so. Where you ordered as an organisation, clause 12 limits our total liability in any twelve-month period to what you paid us in it, and nothing above that figure is promised.
If you want to leave: 1 month's notice, either way, and the act of leaving costs nothing. You get the deployment as it stands — database, file store and configuration — rather than a farewell export, and access is withdrawn on request. Handover work is charged at 110 EUR an hour; leaving is not. Clause 13, and the leaving page in full.
If we would be the wrong supplier: Where a mainstream hosted product already does the job, nobody on your side will own the result, or the deciding factor is the lowest price this quarter, we would decline the work. We would rather lose it than find out in month three.
If something is broken: An outage is counted and never charged, on either support level. There is no availability promise behind that and clause 7 says so: what is promised is how quickly we answer, not that nothing will fail.

Every line above is in the terms of service, the data processing agreement or the leaving page, all three published in full before anyone is asked to sign anything. Where one of them changes it changes there first and here second, and the date it took effect is printed on the document.

Not included: a satisfaction guarantee. What is here instead is the statutory position and the contract, both published in full before anybody is asked to sign either of them.

How it works

A · The six stages, and what lands at the end of each
B · How we charge
C · When we say no
H · DevOps, and what the word covers here

Before you buy

D · What an assessment actually contains
E · What it costs
I · What is agreed in time

Before you trust

F · What we will not do
G · Who you are dealing with
J · If it does not suit