Automated Progressive Rollout: Put the Ramp on a Timer

How to run an automated progressive rollout on a feature flag rollout schedule: choosing steps and hold times, what should pause it, and how it should end.

  • progressive-delivery
  • rollouts
  • percentage-rollouts

The release doc said 1% on Tuesday morning, 5% after lunch, 25% on Wednesday and everyone by Friday. The 1% step went out at 10:40. The 5% step waited until the next day’s standup, because the engineer who owned it spent the afternoon on an incident. Somebody pushed 25% at 4:50 on Thursday so the feature would be done before the weekend, and nobody looked at it again until Monday. The rollout finished roughly on schedule. Every hold in it was set by whoever had a free minute, though, and the 25% step ran for three days with nobody watching.

An automated progressive rollout takes the clock away from people. You write the ladder down once, with the percentages and how long to hold at each, and the flag platform applies each step when its hold runs out. People still decide when to stop, which is the part that needs judgment.

Key Takeaways

  • Manual holds end up wherever people’s calendars put them, which is rarely where the release plan said.
  • Only the percentage should move between steps. With the hash inputs fixed, every step adds users and nobody already in the rollout loses the feature.
  • Size each hold by how many users it reaches and how long the failure you fear takes to show up.
  • A ramp should stop the moment a person edits the rule or the flag goes off, and it should never retry a failed step by itself.
  • Point an error alert at a trigger that turns the flag off, and a bad step stops itself.
  • When the rollout reaches 100%, the flag turns into cleanup work. Plan that step too.

1. Why manual ramps drift off schedule

A percentage rollout done by hand depends on someone’s attention. Each step needs a person to remember it, open the dashboard, find the flag, pick the right environment and move the number. Any of those can slip. The person who owns the rollout is usually the same person who gets pulled into Tuesday’s incident.

The drift goes both ways. A step meant to last four hours can sit for two days because, once the graphs look calm, nobody treats it as urgent. On a Friday afternoon it goes the other way, and two steps get pushed back to back so the feature is “done” before the weekend. We think that’s the worse habit, because the first of those two steps gets almost no time with anyone watching it.

There’s a slower cost as well. After one bad unwatched step, a team will sometimes stop at 50% and leave the flag there for weeks. A flag parked at 50% is half-shipped code that every later change to that area has to account for, in both branches.

2. What a rollout schedule has to get right

Start with the hashing. A percentage rollout decides who’s in by hashing an attribute, usually the user ID, together with a salt, then comparing the result against the percentage. If a step changed the salt or the attribute, the hash would reshuffle, and some users who had the feature at 5% would lose it at 25%. Hold both fixed and raise only the threshold, and each step contains everyone from the step before. The rollout strategies docs walk through the bucketing.

Steps never go down, either. A schedule that could lower the percentage by itself would be making rollback decisions on a timer. Lowering should be a person’s call, made with an abort or a hand edit.

Then there’s the kill switch. Say an alert turns the flag off during the 25% step. The hold should freeze where it is. Otherwise the flag comes back on an hour later and the schedule jumps straight to 50%, having spent no time at all watching 25% after the fix.

A rollout ramp on a timer A step chart of the share of users served the new variation over time. It holds at 1% for one hour, 5% for four hours, 25% for one day and 50% for one day, then reaches 100%. Each step only raises the percentage. Share of users served the new variation 0% 25% 50% 100% 1% · 1 hour 5% · 4 hours 25% · 1 day 50% · 1 day 100% Each step starts when the previous hold runs out (widths not to scale)
The common ladder: an hour at 1%, four hours at 5%, then a day each at 25% and 50% before everyone gets the new variation.

3. Choosing steps and hold times

The 1, 5, 25, 50, 100 ladder shows up in most rollout guides, ours included, and we have no quarrel with it. Holds cause more trouble, often because they were copied from a service with very different traffic. So how long is long enough? A hold needs enough users passing through it to show a problem (well, enough failing requests to stand out from the errors you already get), and enough time for the problem you’re worried about to surface.

To count users, multiply the users who hit the flag per hour by the percentage and by the hours held. Returning users count once, so treat these as upper bounds.

Users per hour1% for 1 hour5% for 4 hours25% for 1 day
3,0003060018,000
300,0003,00060,0001,800,000

At 3,000 users an hour, the first step reaches about 30 people. If the new code fails one request in a thousand, you’ll almost certainly see nothing. A low-traffic service should hold that first step for a day, or start at 5%. At 300,000 an hour, the same hour at 1% tells you a great deal.

Then think about speed. Exceptions and latency show up within minutes, but a memory leak can take most of a day to climb high enough to page anyone, and a bug in a nightly job won’t appear until that job has run. Anything tied to a weekly or monthly pattern, like a Monday traffic peak or a billing run on the first, needs a step that spans that event. Make the longest hold at least as long as the slowest failure you can name. If you can’t name one, a day each at 25% and 50% covers what a daily cycle will surface.

Put the long holds near the top of the ladder, at 25% and 50%, before the step that sends everyone over.

4. What should stop an automated rollout

When someone steps in, the schedule should get out of the way. If it kept going, it would override their decision on its own timer. In Featureflip a ramp pauses itself in these cases.

A flag trigger is a secret URL that a monitoring tool calls when an alert fires, and pairing one with a ramp is the setup we’d recommend first. Point a Datadog or Grafana error-rate alert at a trigger that turns the flag off, and a bad step shuts itself down. The flag goes off for everyone, which is the kill switch doing its job, and the ramp waits at the step that caused it. In the morning, someone reads the alert, ships a fix, turns the flag back on and resumes.

5. Time-based ramps and metric-gated canaries

Some tools gate each step on metrics instead of time. Canary analysis in Argo Rollouts or Flagger compares the new version’s error rate and latency against the old one, then promotes or aborts on its own. It works at the deployment layer, on the traffic split between two versions of a service, and it needs per-version metrics you trust.

A time-based ramp on a feature flag moves users between two code paths inside a single deploy. It suits changes with no clean per-version metric, such as a UI change, a new onboarding flow or a swapped AI model. Its gate is an alert you already run. The trade-off is that a metric-gated canary can catch a regression too small to cross an alert threshold, and a ramp with a trigger can’t. With good alerts, the ramp and trigger catch the failures that matter most. Teams that don’t trust their alerts should fix those before relying on either approach. The progressive delivery explainer shows where each technique sits.

6. How a rollout should end

A flag left at 100% keeps working. Every evaluation returns the same answer, though, and the code still carries both branches, so somebody has to remove it eventually.

Featureflip treats a default-rule ramp that finishes at 100% as a hand-off to cleanup. The rollout folds away, and the ramped variation becomes the flag’s default variation, as if you had set it by hand. Contexts that lack the Bucket by attribute kept getting the old default throughout the ramp, and they switch to the new variation at this point. The ramp dialog warns about it before you start.

Once a single fixed variation is being served, the flag matches the Fully rolled out signal in stale flag detection. After 30 days it’s marked Stale, your cue to delete the old branch and remove the flag. The flag lifecycle guide picks it up from there.

7. Setting up a ramp in Featureflip

Open the flag and pick the environment. Then click Ramp rollout on a rule that has a percentage rollout, or on the Default rule rollout card. Load the preset ladder or write your own steps, up to 20 of them with holds anywhere from five minutes to 30 days, and start it. The flag has to be on.

While it runs, the rule card shows something like Step 2 of 5 · 5% · next step to 25% in 3h 12m. Every step is an ordinary rule update. It lands in the audit log with a reason like Rollout ramp step 3 of 5: 50%, sends a targeting_rule.updated webhook, and reaches connected SDKs over the stream within seconds. Pause, Resume, Advance now and Abort live on the same card, and Abort can only keep or lower the percentage. In a critical environment that requires change reasons, each control asks for one.

Ramps are on the Team plan and above. The rollout ramps guide lists every rule and limit, and the progressive rollouts use case covers what to watch at each step.

The shorter version

Frequently asked questions

What is an automated progressive rollout?

It’s a percentage rollout that raises itself on a schedule. You set the steps, such as 1%, 5%, 25%, 50% and 100%, and how long to hold each one, and the flag platform applies each step when its hold ends. People can still pause, skip ahead or abort at any point.

How long should each step of a rollout last?

It depends on your traffic and on how slowly your likely failures appear. A common starting point is an hour at 1%, four hours at 5%, and a day each at 25% and 50%. A service with a few thousand users an hour should hold the first steps longer, since an hour at 1% reaches only a few dozen people.

Can a rollout pause automatically when error rates rise?

Yes, if an alert can reach the flag. In Featureflip, point a monitoring alert at a flag trigger that turns the flag off. The flag goes off for everyone, and the ramp pauses with the rest of its hold intact until someone turns the flag back on and resumes.

Does raising the rollout percentage change who sees the feature?

It only adds people. The hash that places each user stays the same between steps, so anyone who had the feature at 5% still has it at 25%. Changing the Bucket by attribute or the salt would reshuffle users, which is why a ramp never touches either.

What happens when an automated rollout reaches 100%?

On a Featureflip default rule, the rollout folds into the default variation and the flag serves one fixed value. After 30 days of that, stale detection marks it Stale so the flag and its old code path can be removed.


Featureflip is a flat-priced feature flag platform with rollout ramps, flag triggers, stale detection from real evaluation traffic, and a cleanup Action that opens a pull request to remove each dead flag on GitHub, GitLab or Bitbucket. Start on the Free plan without a credit card. Ramps come with the Team plan.