Monthly engineering capacity
Product engineering retainers with fixed monthly capacity
For startups with a live product that still needs fixes, updates, and new features. A product engineering retainer gives you a fixed amount of engineering time each month, from a few hours to dedicated developers, with a set response time and a named lead who knows your code.
- Price
- Scoped on a call
- Model
- Monthly capacity
- Timeline
- Monthly, with a 3-month minimum term (6 months for Embedded)
What it is
What is a product engineering retainer?
A product engineering retainer is a monthly agreement in which a startup buys a fixed amount of engineering capacity, with a set response time, to keep a live product fixed, updated, and improving after launch. Pixelact offers four tiers, from 5 to 8 hours a month to dedicated full-time developers, once a build has proved its value.
You need this when
Our product launched, and we need someone who knows the code to fix bugs and keep dependencies current.
We have paying customers and a backlog of features and integrations, but no engineering team of our own yet.
We need developers who work only on our product, and we don't want to run the hiring ourselves.
Our app was stabilized after a rescue, and we want it kept healthy instead of drifting back.
We want a predictable monthly engineering cost instead of quoting every small change as a new project.
What you get
What you get at the end
Every deliverable is written down in the proposal before work starts, so you know exactly what you are buying.
- 01
Fixed monthly capacity
A set number of hours or sprint points each month, from 5 to 8 hours up to full-time developers, with your tier's response time written into the agreement.
- 02
A named lead who knows your code
One person triages requests, agrees priorities with you, and tracks every change through review and release, so context doesn't reset each time you ask for something.
- 03
Fixes, updates, and monitoring
Bug fixes, dependency upgrades, and security patches on every tier. From Maintain upward, we also watch errors, uptime, and slow queries, so we can act before customers report a problem.
- 04
Shipped features and integrations
On Improve and Embedded, new features and integrations go through the same code review, CI tests, and preview environments as the original build.
- 05
A monthly capacity report
What the capacity went to, what shipped, what rolled over, and what is next on your list.
- 06
Handover-ready documentation
The README, runbooks, and architecture decision records kept current as the code changes, so any engineer can pick the product up.
How it works
How it works, step by step
A written process with a named lead, so you always know what happens next and who owns it.
- Step 01
A build proves its value
Retainers follow a product build, an internal tool, an AI system, or a rescue stabilization sprint, so the team behind your retainer already knows the code. Build proposals include a retainer option unless you tell us you don't want one.
- Step 02
Tier and agreement
We look at your backlog, release rhythm, and how quickly issues need an answer, then recommend a tier. The written agreement sets the capacity unit, response time, minimum term, notice, and for Embedded each developer's start date.
- Step 03
Onboarding
We agree where requests go, usually your issue tracker, who can raise them, and what counts as urgent. Access stays in your accounts, and your named lead confirms the first month's priorities.
- Step 04
Monthly work
You pay monthly in advance, and the capacity goes to your ranked list. Each change is reviewed, tested in CI, and released with a rollback path.
- Step 05
Monthly review
You see what the capacity went to, what shipped, and what rolled over. Then we agree next month's priorities and check that the tier still fits.
- Step 06
Handover when it ends
When you give notice after the minimum term, we bring the README, runbooks, and decision records up to date, then walk whoever takes over through the code and the open decisions.
What does a product engineering retainer cover?
#A product engineering retainer covers the engineering work a live product needs every month: fixing what breaks, keeping dependencies and infrastructure current, and shipping the next features. You buy a fixed amount of that capacity, and a named lead who already knows the code spends it on your priorities.
- Bug fixes, triaged by how many customers they affect
- Dependency upgrades and security patches, prioritized when an advisory affects a version you run
- Monitoring of errors, uptime, and slow database queries, from the Maintain tier upward
- Backup checks that restore a copy, not only confirm that the backup job ran
- New features and integrations on Improve and Embedded
- For AI features, rerunning evals when a model or prompt changes
Every change follows our engineering standards: reviewed before merge, tested in CI, and released with a tested rollback path, with risky features behind a feature flag. Our guide to safe releases and rollbacks shows that process step by step.
Which retainer tier fits your product?
#Choose the tier by how much the product still changes and how quickly issues need an answer.
| Tier | Built for | Capacity per month | Response time | Minimum term |
|---|---|---|---|---|
| Maintain Lite | Fixes and updates for small builds | 5 to 8 hours | 3 business days | 3 months |
| Maintain | Fixes, updates, and monitoring | 20 hours | 2 business days | 3 months |
| Improve | New features and integrations | 50 hours | 1 business day | 3 months |
| Embedded | Dedicated full-time developers on your product only | About 160 hours per developer | Same working day, within agreed overlap hours | 6 months |
Software maintenance retainers: Maintain Lite and Maintain
#A software maintenance retainer suits a product whose features are mostly settled. Maintain Lite fits a small build, such as an internal tool one team uses, that needs occasional fixes and updates. Maintain adds monitoring and enough hours for a steady flow of bugs, small changes, and dependency upgrades on a customer-facing product.
Improve: ongoing feature development
#Improve is for a product with paying customers and a roadmap. At 50 hours a month, it covers new features, integrations, and performance work alongside maintenance. It is also the usual next step after a software rescue, so a stabilized codebase keeps getting better instead of sliding back. The performance and scalability checklist shows which performance work to plan first.
Embedded: a dedicated development team
#Embedded gives you full-time developers who work on your product only, about 160 hours each a month. We hire them for your contract and handle code review, technical direction, and replacements, so you get a dedicated development team without running recruitment. A new hire usually starts 2 to 3 months after signing, and the agreement states each developer's start date.
How does monthly capacity work?
#You buy a fixed amount of capacity each month, never unlimited work. The agreement sets the unit, the response time, and what happens to time you don't use.
- Capacity
- Measured in hours or sprint points, chosen in your agreement.
- Response time
- How long a request raised in the agreed channel waits before a named engineer picks it up and replies with a plan. It is not a promise that the fix ships within that time.
- Rollover
- Unused capacity carries into the next month only, capped at 25% of monthly capacity. Carried-over time still unused at the end of that month expires.
- Extra work
- Work beyond the month's capacity is billed separately and agreed with you before it starts, or it moves into the next month.
A rollover example
On Maintain, at 20 hours a month, at most 5 hours can roll over. If March uses 12 of its 20 hours, 5 of the 8 unused hours move to April, which then has 25. Any of those 5 still unused at the end of April expire.
How is an engineering retainer priced?
#Each tier is a fixed monthly fee, paid monthly in advance. We don't publish retainer prices. They are scoped on a call and set out in writing, usually as the retainer option in a build proposal.
- By capacity or by developer. Maintain Lite, Maintain, and Improve are priced by the tier's capacity, and Embedded per developer.
- Terms. A 3-month minimum term, or 6 months for Embedded. After it, notice is 30 days, or 60 days for Embedded.
- Price changes. A retainer price can rise once a year with 60 days' notice, unless your agreement fixes the price for its term.
Why is a retainer offered only after a build?
#A response time only means something when the team behind it knows the code. So we offer a retainer once a product build or a rescue stabilization sprint has proved its value and we have worked in the codebase ourselves.
If someone else built the product, start with a fixed-fee software audit. It shows what state the code is in, and for an unstable product it runs as a rescue audit that ends in a fix-or-rebuild call. A stabilization sprint or a rebuild then comes before any retainer, so we have worked in the code before we commit to a response time.
How should we prepare for ongoing development support after launch?
#Ongoing development support after launch works best when requests arrive ranked and someone on your side can decide. Bring these to the call.
- A ranked list of bugs, small changes, and features, however rough
- One person who sets priorities and accepts finished work
- Admin access to the repository, hosting, error tracking, and issue tracker, all held in your accounts
- A plain definition of urgent for your product, such as checkout failing or a customer locked out
- Known technical debt, sorted with our technical debt triage checklist
How does a retainer compare with hiring or a dedicated development team?
#A retainer gives you steady, capped capacity from engineers who already know your code, without building your own team first. The other options fit different stages, and the table shows where each one works.
| Option | Works well when | Watch for |
|---|---|---|
| Hiring in-house | You need full-time engineers for years and can recruit now | Hiring takes time, and one first hire carries every review and incident alone |
| Freelancers billed hourly | A specific task has a technical owner on your side | Availability shifts with their other clients |
| Quoting each change as a project | Changes are rare and can wait for a quote | Small fixes wait on paperwork, and nobody watches the product in between |
| A vendor's dedicated development team | You need several full-time developers and can direct them | Ask who reviews code, sets technical direction, and replaces a developer who leaves |
| Pixelact engineering retainer | A live product needs steady capacity from engineers who already know the code | Capacity is fixed, so a sudden large project is scoped separately |
Before you sign with any provider, us included, ask what counts against capacity, what happens to unused time, and how the work is handed back when the agreement ends. Our guide to choosing a software development partner covers the wider questions.
FAQ
Common questions
Straight answers on scope, price, ownership, and what happens next.
Unused capacity rolls into the next month only, capped at 25% of your monthly capacity. On the 50-hour Improve tier, for example, up to 12.5 hours can carry forward. Carried-over time still unused at the end of that next month expires, which keeps capacity tied to planned work rather than a growing balance of owed hours.
Yes, once we have worked in the code. We start with a rescue audit, a software audit at the same fixed fee that ranks risks and fixes and ends in a fix-or-rebuild call. A fixed-price stabilization sprint or a rebuild follows, depending on that call. After either one, an Improve retainer is the usual way to keep the product healthy.
The minimum term is 3 months for Maintain Lite, Maintain, and Improve, and 6 months for Embedded. After that, you can end the retainer with 30 days' notice, or 60 days for Embedded. The code, repository, and accounts are already yours, so ending a retainer means a handover walkthrough, not a move of code or accounts.
No. Response time is how long a request waits before a named engineer picks it up and replies with a plan: 3 business days on Maintain Lite, 2 on Maintain, 1 on Improve, and the same working day within agreed overlap hours on Embedded. How long a fix takes depends on the problem, and that first reply tells you what we expect.
Embedded developers work full days on your product only. They take work from your issue tracker, commit to your repository, and join your planning during the overlap hours set in the agreement. A Pixelact lead reviews their code and sets technical direction, and if a developer leaves, we find and onboard the replacement.
Extra work is billed separately and agreed with you before it starts, or it moves into next month's capacity. If you keep running over, the product probably needs the next tier up, and we will say so at the monthly review rather than let overruns become the normal way of working.
You do. The work happens in your repository, on hosting and services held in your accounts, and you pay those providers directly. Every change is reviewed and documented as it ships, so the record of what changed and why stays with you. After the minimum term, you are free to move the work in-house or to another partner.
Our working day overlaps with UK and European business hours, and we schedule calls with US and Canadian teams in their morning. On Embedded, the agreement sets the overlap hours that the same-working-day response applies to. We reply to every project inquiry within one business day.
Related
Where to go from here
Related services, guides, and checklists.
Start a project
Tell us what you're building.
Share a few details in a short form, or book a discovery call if you're not sure where to start.
On the discovery call
- 01What prompted this now, and where things stand
- 02What a good outcome looks like
- 03Whether we're a fit, and what a next step could be
45 minutes. No slides, and no long questionnaire.