# Product engineering retainers with fixed monthly capacity

URL: https://pixelactstudio.com/services/engineering-retainers

> How a product engineering retainer works: four tiers of fixed monthly capacity, set response times, minimum terms, notice, and the rule for unused hours.

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.

- Price: Scoped on a call
- Model: Monthly capacity
- Timeline: Monthly, with a 3-month minimum term (6 months for Embedded)

## Who it is for

- 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

- **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.
- **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.
- **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.
- **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.
- **A monthly capacity report:** What the capacity went to, what shipped, what rolled over, and what is next on your list.
- **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

1. **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.
2. **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.
3. **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.
4. **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.
5. **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.
6. **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.

## Not included

- Unlimited work or an open-ended queue. Each month has the fixed capacity set in your agreement.
- Round-the-clock on-call. Response times count business days, or agreed overlap hours on Embedded.
- Hosting, paid APIs, and licenses. Those accounts stay in your name, and you pay providers directly.
- A new product or a major rebuild, which is scoped as a [product development](https://pixelactstudio.com/services/product-development) build with its own milestones.
- Ongoing brand design, which runs as a separate [brand design retainer](https://pixelactstudio.com/services/brand-retainers).

## 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](https://pixelactstudio.com/about/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](https://pixelactstudio.com/blog/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.

**Pixelact engineering retainer tiers**

| 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](https://pixelactstudio.com/services/software-rescue), so a stabilized codebase keeps getting better instead of sliding back. The [performance and scalability checklist](https://pixelactstudio.com/resources/performance-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](https://pixelactstudio.com/services/product-development) 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](https://pixelactstudio.com/services/software-audits). It shows what state the code is in, and for an unstable product it runs as a [rescue audit](https://pixelactstudio.com/services/software-rescue) 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](https://pixelactstudio.com/resources/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.

**Ways to fund engineering after launch**

| 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](https://pixelactstudio.com/blog/choosing-a-software-development-partner) covers the wider questions.

## Frequently asked questions

### What happens to unused retainer hours?

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.

### Can we get a retainer for a product you didn't build?

Yes, once we have worked in the code. We start with a [rescue audit](https://pixelactstudio.com/services/software-rescue), 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.

### What is the minimum term, and how do we end a retainer?

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.

### Does the response time mean the problem is fixed within that time?

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.

### How do Embedded developers work with our team?

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.

### What if we need more than our tier in a month?

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.

### Who owns the code written on a retainer?

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.

### Which time zones do you work with?

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.