Je compare le cash flow net (travaux, impôts, vacance) sur la durée de détention réelle au rendement d'un World. Sur un locatif en SCI que j'ai rénové, ça casse sur une ligne : mon temps de gestion. Vous le chiffrez comment, ou vous le laissez à zéro ?
Reading the customization thread from the other side of the table. I'm a product manager on a configurable B2B platform covering HR, financial and operational workflows, so customization requests reach me after they've already been through someone's internal filter. By then they arrive as a specification: add a field here, an extra approval step there. What almost never comes with it is the process it came from, or what actually breaks if nothing changes.
So my first move is to push it back and ask for the workflow, because a decent share turn out to be configuration the requester didn't know existed, and another share are a process the customer could change more cheaply than we can change the software.
That works fine in a normal prioritization round. It falls apart when it's an escalation with a date attached, and then the spec wins anyway.
The part I'm least sure about is whether the pushback quietly makes things worse. People stop asking, build the workaround in a spreadsheet or a script nobody owns, and I never find out the gap existed at all. If you sit on the implementing or admin side: has a vendor refusing a customization and asking about the process ever ended in a better answer than the customization, or did you just route around them and keep the spreadsheet?
I can tell you what building internal Product Ops tooling instead of buying a product tool actually costs. I can't tell you whether it holds up with a bigger team.
We already ran delivery in GitLab, so I built on top of it rather than adding another subscription:
The build wasn't the expensive part. The expensive part is that it stays useful only while I'm the person maintaining it. Every field either earns its keep or quietly rots.
Where it breaks: Customer Success and the operational stakeholders don't live in GitLab. For them it's still me pulling a view out by hand, which is the reporting layer I was trying to avoid. If you've built your own Product Ops tooling, what did you do when the people who needed the output weren't in the system it was built on?
The item that breaks refinement for us is not the badly written one. It is the well written one with nothing behind it: a specific ask from one customer, clear enough that the devs can size it, so nobody in the room objects. Estimation works fine. Discovery never happened.
What I do now is refuse to take an item into refinement without three lines: the problem, who hit it, and how we know. On a configurable B2B platform that also catches the requests that turn out to be a configuration change rather than a product gap, which is worth the friction on its own.
Where I am less sure: when it is an escalation from one unhappy customer, holding that bar costs days of goodwill for evidence I already know I will not get. I'd say hold it anyway, though it depends on how much of your roadmap is escalation-driven.
Has anyone seen that bar be the wrong call, where insisting on a problem statement before refinement cost the team more than just building the stated request would have?
The fields that survived on our GitLab backlog are the ones something else breaks without: release label, area, and a short decision note on anything that gets prioritized. Everything I added because it would be useful later decayed within a couple of cycles.
I built the Product Ops layer around GitLab to consolidate a large backlog and make releases, prioritization and capacity readable. What holds is what is load bearing. Release labels hold because release coordination fails visibly without them. The decision note holds because I write it at the moment the call is made rather than when someone challenges it months later, and I am the person who gets asked.
What decayed is everything describing the problem behind a request: evidence links, how confident we were, the line between what a customer actually said and what we assumed. Those are exactly the fields I want when Customer Success asks what happened to their request, and exactly the ones nobody keeps current, including me, once the item is moving.
My working conclusion is that a field survives only when someone downstream is blocked without it, which means discovery context is almost never load bearing inside a tracker. I would say that holds generally, though it probably depends on how much of it a tool can fill in instead of asking a person to type it.
The part I am least sure about is whether to stop keeping problem context in the tracker at all and hold it somewhere else. Has anyone got evidence and assumption fields to stay current inside the tracker itself, and what was the thing that actually forced people to update them?
The part of this loop that breaks for me isn't intake, it's six months later. A request comes in from CS, goes through discovery, gets merged with two others, and ships as something that solves the underlying problem but looks nothing like what was asked for. When the CSM goes back to the customer, nobody can reconstruct which parts of the original ask survived, or why the rest didn't.
I built internal tooling around our GitLab backlog partly for this: link the request to what actually shipped, so the chain at least exists. That holds while the shape of the thing stays stable. It stops holding when the requirement changes mid-flight for a reason that lived in a call and was never written down anywhere (the decision is usually sound, it's just invisible afterwards).
So the case where my approach breaks is when the honest answer is "we decided differently in a conversation you weren't in." For the CS side: do you want to hear about that the moment it happens, even when it isn't final and might change again, or do you prefer one clean explanation at release and nothing in between?
Most feature requests that reach me from Customer Success arrive as a solution already: a field here, a toggle there. On a configurable platform that is awkward, because a good half of them can be satisfied with configuration, and doing that quietly is how you end up with fifty customers on fifty different setups.
So before anything goes near the backlog I ask CS for two things: the workaround the customer runs today, and who else has asked. Workaround exists, one customer asking: it stays a configuration change. Same workaround showing up a third time: I treat it as a product gap and go and look at the underlying workflow rather than the ask.
Three is a number I made up. It has held so far, but that is not evidence.
For anyone else on a configurable product: what actually made you promote a repeated configuration workaround into the product itself, and what did you do with the customers already sitting on the old setup?