How I spread the stages of a feature across my team, so more than one person can step in when something goes wrong.
During one release, people took time off one after another, with no gaps. The project kept moving as if nothing had happened, and the release ended smoothly. It wasn't always like that.
The fastest way to deliver a feature is to let the person who investigated it build it. They already know the requirements, the design and the plan, so nobody can start faster. In my team, that's what used to happen, and it looked like the right call until that person wasn't available.
The fastest option creates a silo
Every new feature in my team started with an investigation: looking at the requirements, designing the feature from a technical architecture point of view, checking it was feasible and coming up with the approach. We then split the approach into tickets. The person who did the investigation naturally picked up those tickets. It was the easiest option, because they had already done the investigation and made the plan, so they would be the fastest at delivering it. At first this seemed great, because it got us the feature as quickly as possible.
It became a problem when that person became a bottleneck. They could be sick, on holiday, gone from the team, or caught up in another important feature they also owned. Whatever the reason, the time we had gained at the start was lost. We had to work out who was available and who could understand the topic well enough to help without the person who built it.
We had several silos like this, and we kept getting stuck because so few people could help when something went wrong. It affected people too. When one topic went completely wrong, the one person who owned it carried all of it, and one of them was getting burnt out.
Every person owns a different part of the feature
Every feature has four parts: the investigation, building the different parts of the feature, reviewing them, and building an additional part later on. My approach is that no one person owns all of them.
Take a team with three developers: Dev A, Dev B and Dev C.
Dev A does the investigation, presents it to the team in a meeting and explains the approach. The team reviews it and contributes. Reviewers either approve it in the meeting or ask for more time with the document and approve it later. Then we split the feature into tickets.
That meeting is where the context starts to spread. Everyone hears the approach and shapes it, so all three developers start with the same picture. Dev A will know more of the detail, and that's fine.
Dev B picks up the first ticket, and Dev A and Dev C review it. They didn't build it, but reviewing it gives them enough context to build on top of it. Dev C picks up the next ticket, and Dev A and Dev B review it. And so on. With every step, everyone gains context.

When an additional part comes later, anyone who wants it or is available can take it. The exception is someone who hasn't touched the feature yet. It's their turn, because it's their place to get comfortable with it.
Everyone ends up knowing enough
After a few rounds, every developer has the same, or a similar, knowledge of the topic. Each has more detail on the parts they owned, and enough to fill in the gaps on the parts they only reviewed.
The investigation and the architecture are documented, so filling in a gap, or coming back to a feature after a while, jogs everyone's memory. It also makes it easy to hand a topic over to a new team or a new joiner.
It's a little slower, and it's worth it
Rotating does slow down delivery, but not by a noticeable difference. The cost is spread over small increments at every stage, and it pays off in high-stakes situations.
I use it for medium to large, complex features. A feature that takes one or two tickets usually isn't worth the hassle.
Nobody is a single point of failure, so I have more options
Because anyone can pick up a topic, I'm not limited when I assign and delegate. I have more flexibility and more choices.
Say a critical issue comes in on a topic Dev A is off from. Without this approach, I'm either blocked waiting for Dev A, or Dev B or Dev C has to spend time onboarding before they can help. With it, Dev B solves it. If Dev B is working on another high-priority ticket, Dev C takes it. Every developer could be unavailable, but the number of options is much higher before we reach a standstill.

Nobody carries a topic alone
I'm a big advocate of my team not burning out. When no one person is constantly required to lead a topic, no one is under pressure to carry it. Developers can take over from each other for whatever reason, even if it's only that one of them is having a bad day. My developers and I appreciate that.
When every developer is available and the issue is high priority and critical, we can go all hands on deck. Everyone has enough context to brainstorm the fix together, so nobody is under pressure to solve it alone.
Explain the why, then test it
When I introduced the rotation, I started with the problem: the silos and the times we got stuck. As with anything new in my team, we tried it and reflected on whether it actually worked for us. The result was a success. It benefited everyone and cost us very little speed, so we adopted it.
Who can help isn't the question anymore
The person who investigates a feature will always be the fastest to build it. I stopped choosing that option. The silos in my team came from picking the fastest option every time. Nobody was at fault. Now each feature is spread across the team, so when something goes wrong, the question isn't who can help. It's who is available first.