SaaS

The Business Behind the Software

Funding a feature does not have to mean surrendering the roadmap.

A Customer Can Fund the Work, Not Own the Roadmap

Priya Raman Avatar

No ratings yet

A large customer offers to pay for a feature your open-source project needs. The engineering work is feasible, the money would buy months of runway, and you can already picture the announcement. Then the customer asks for one more thing: a commitment that their request will take priority over other work until it ships.

That is the moment to distinguish a purchase from a transfer of control. Customers can pay for development. They should not quietly acquire the power to decide what the project becomes.

A Customer Can Fund the Work, Not Own the Roadmap
The right delivery path depends on who will maintain the work.

Funded work still needs a product decision

A customer’s request is useful evidence. They have a real problem and enough urgency to spend money on it. But willingness to pay does not establish that the proposed solution belongs in the shared product. It may solve a workflow peculiar to one company, introduce a maintenance burden for everyone, or depend on assumptions other users do not share.

Before quoting the work, ask what you would ask of an unfunded proposal: Who else has this problem? Does the design fit the project’s architecture? Who will maintain it after delivery? The customer’s budget can move a good idea forward. It should not exempt the idea from scrutiny.

This does not mean every sponsored feature must benefit every user. Many valuable capabilities begin with one demanding adopter. The test is whether you can explain the feature’s place in the product without referring to the customer who paid for it.

Separate delivery promises from roadmap authority

Commercial contracts need concrete obligations. A customer should know what they will receive, when they can test it, and what happens if the work changes scope. None of that requires promising that every requested implementation detail will land upstream.

Make the distinction explicit before signing:

  • Delivery: Define the behavior or outcome the customer is buying and the acceptance process for that work.
  • Design: Reserve room to change the implementation when review reveals a better approach.
  • Upstream inclusion: State which changes are intended for the open project and which remain subject to its normal review process.
  • Priority: Commit to your team’s delivery schedule, not to control over every maintainer’s priorities.

If you control the entire project, you may have the authority to make those decisions yourself. You still benefit from separating them. A contract that turns a customer’s preferences into permanent product obligations can constrain you long after the invoice is paid.

Keep the public process genuinely public

The most corrosive version of sponsored development is a decision made privately and presented to the community as an open discussion. People notice when an RFC invites feedback on a design that is already contractually locked. The issue tracker remains public, but the decision-making has moved elsewhere.

Publish the problem and proposed approach early enough for feedback to matter. Say that the work is funded; there is no need to pretend the timing arose organically. Explain which constraints are fixed, which choices are open, and who will make the final call. Transparency will not make everyone agree, but it gives contributors an honest account of the process they are entering.

Sometimes a customer cannot discuss its use case publicly. You can still describe the general problem without exposing sensitive details. If even the requirements cannot be shared, consider whether the work belongs in a private integration rather than the project’s public core. Do not ask community reviewers to bless a design they cannot evaluate.

Price the maintenance, not just the build

The initial development fee is easy to calculate. The expensive part may arrive later: compatibility across releases, documentation, support questions, and architectural decisions constrained by a feature that one customer no longer uses.

Include ongoing ownership in your internal estimate. If the feature becomes part of the shared project, your company needs a plan to maintain it even if the customer leaves. If that cost does not make sense, propose a narrower interface, extension point, or separately maintained component. Those options are not second-class outcomes. They may be the most responsible way to solve the customer’s problem without handing the project a permanent bill.

This is also why “the customer will maintain it” needs more than a friendly assurance. People change jobs and budgets disappear. Decide what happens if that maintenance stops before you merge the work.

Be willing to sell a different answer

A customer may want an upstream feature because it sounds durable, or because they do not want to own a customization. Those are reasonable concerns. They do not oblige you to put a poor fit into the core.

You can offer a supported integration, fund a more general capability, or decline the project. The harder conversation is usually cheaper than shipping a design you cannot defend to your users or maintainers. A good commercial relationship is not one in which the customer gets every architectural decision. It is one in which they know what you can promise—and trust you to keep promising only that.

Enjoyed this? SaaS is supported by readers. Become a sponsor →

Get new SaaS articles by email, once a day, with a roundup of the week on Sundays.

Free, from scike.ai. Unsubscribe any time. Add other Scike sites

Quiz

Test Your Knowledge

Think you absorbed it all? Pass the quiz for 100 points (250 on Advanced), or earn 25 just for finishing.

You've passed this quiz. Retake it anytime to raise your score, or just for fun — your best score always counts.

Top Scorers

No scores yet — be the first!

Comments

3 responses to “A Customer Can Fund the Work, Not Own the Roadmap”

  1. Dane Whitlock Avatar
    Dane Whitlock

    The tempting number is the check. The useful number is what remains after delivery and maintenance. A $40,000 contract looks like four months of runway for a team burning $10,000 a month. But eight hours of support every month adds up to 192 hours over two years. For a tiny team, that is nearly five weeks of work.

    Before I sign, I want a deposit, a written acceptance test, and a named owner for the work after launch. I also want the freedom to meet the customer’s need through an integration if the proposed feature does not belong in the core.

    That last option matters most when cash is tight. If the contract only works when you promise to merge a specific design, the customer is buying more than development. They are spending your future capacity.

  2. Mara Delgado Avatar
    Mara Delgado

    A request for priority is often a request for certainty. You can sell that without selling roadmap control. Price a defined delivery window or reserved engineering capacity, with clear limits on what the customer gets to approve.

    The pricing trap comes later. If a sponsored feature lands in the core product, the build fee does not cover its lifetime cost. Before signing, ask whether other customers would pay for it too. If not, a supported integration may be the better product and the more honest deal.

  3. Eli Brandt Avatar
    Eli Brandt

    A customer can buy faster work from your team. They cannot buy a guaranteed yes from the project.

    That distinction needs a price tag, not just a principle. Sell a supported outcome with a clear fallback if upstream review changes the design. Price ongoing maintenance separately. Otherwise a one-time development fee can become a lifetime obligation to defend someone else’s feature.

Leave a Reply

Browse and Search