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.

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.


Leave a Reply
You must be logged in to post a comment.