I'd like to explore developing a more open paid prioritization flow -- specifically, something that says "this is what we offer, how it works, and how much it costs". I think the two major issues we see today are:
- There's a lot of overhead in contract setup, which is bad on both sides.
- Stuff stalls on customers, who are generally less nimble than we are.
I'm not sure we can really fix (1), since engineers are usually the ones who want features and they don't usually have permission to approve expenses, but I think there's a good chance that we can reduce the amount of overhead we deal with by pushing the service toward something that looks more like a commodity. Ideally, the process would be something like buying a new monitor and expensing it.
I'm sure we can't fix (2), but we can try to push more of that cost back onto customers so we aren't stalled.
At least some of the contract setup cost is aimed at protecting the parties from risk. Our service already exposes customers to very little risk, and we can eliminate more of it. In particular:
- Disclosure Risk/NDA: We don't normally have any access to private data anyway, and generally don't want this access.
- Nonsolicit/poach: I think we can offer this in a blanket way to anyone who pays us for anything (I believe we don't ever care about it, but we should be more clear about exactly where the monopoly/antitrust stuff kicks in before we offer a button that you click to stop us from hiring your employees).
- IP/Work Product: We always own all our work product. We've historically needed to strike this section out of contracts anyway.
- Nondelivery/Acceptance: I think this is the notable part: we can eliminate this risk completely. Basically, this amounts to a "if you aren't happy, don't pay us" structure. Specifically:
- We have plenty of buffer relative to the size of projects (which are maybe a month long at the very outside), and we can always accept payment on delivery.
- If customers bail/flake, we don't lose very much. We still own our work, and it's always stuff we would have built anyway and are willing to maintain.
- If customers aren't happy, we can just decline to accept their requests in the future.
- Since we choose what we accept, we can balance this for new customers with large requests.
Ideally, that would let us get paid prioritization structured in a consistent way that can be made relatively public, which could eventually help with (2) by exposing the queue and making the rules around the queue automatic and clear ("if stuff blocks on you for X time, your stuff falls down the queue").
Here's a very rough draft of what this might look like...
If you'd like to get a specific feature built right away, Phacility offers paid prioritization. The service we provide works like this:
- We'll prioritize a feature you're interested in and build it as soon as possible.
- We'll charge you $150/hour for the time we spend working on it.
- This service is risk-free. Payment is not due until delivery. If you aren't completely satisfied, you aren't expected to pay us.
What Can Be Prioritized
The service we offer gives you control over our development priorities, not access to custom development. Everything we build will go into the upstream and be released as open source. We'll retain ownership of all our work product and intellectual property. In exchange, we'll maintain the feature in the upstream indefinitely, for free.
Because we're committing to an indefinite maintenance window, we're only willing to prioritize features that reasonably fit into our roadmap. If you have a very narrow use-case which is specific to your organization, this may not be a good fit for what you're interested in. Fortunately, our roadmap is vast and most of the features users have ever requested fit into it. For example, almost everything in Maniphest is suitable for prioritization.
Payment is due only on delivery. If you aren't completely satisfied with the product, timeline, price, or any other aspect of the service, you are not expected to pay us.
This is an unusual way to structure service offerings, but aligns well with how we provide services. Specifically, the cost of negotiating, reviewing, and executing contracts is far higher for us than the cost of accepting all of the delivery risk.
If this sounds like something you might be interested in:
- Send us an email at email@example.com describing the feature you're interested in prioritizing (usually this is just a task number from Maniphest).
- We'll give you a rough quote and timeline, and discuss any considerations relevant to the specific feature you're after.
- If those sound reasonable to you, we'll prioritize development.
- After we ship the feature, we'll invoice you for the time we spent developing it.
- Pay the invoice only if you're completely satisfied with the service, timeline, price, and product.
Phacility Prioritization Service Agreement
This document describes the prioritization service we offer. We want to make sure your expectations are clear before we agree to prioritize work for you.
You may offer to pay us to prioritize the development of certain software features. At our discretion, we may accept your offer. This process is informal and does not create an obligation for either party: we have no obligation to deliver the work, and you have no obligation to pay us.
We Own Our Work
We own all the work we produce and retain all of the intellectual property rights. We will release the work as part of the Phabricator upstream, under the same open source license that Phabricator is normally available under. This will allow you (and all other users) to benefit from the work. We do not offer custom or closed-source development services.
As the work becomes available, you (and all other users) may use the work in accordance with the license. Paying us to prioritize work does not grant you any special rights to the work, and does not imply any additional warranty. Your rights with respect to the work are dictated solely by the software license and are no different from the rights of other users.
We will maintain work we produce indefinitely, without cost. We will decline work which we believe we can not maintain indefinitely, unless we reach an agreement about the lifetime of a feature.
On rare occasions, unforeseen events (including changes in our plans for the product) may affect our ability to maintain a feature, and we may remove features from the product, including features we have prioritized for you. If we do, your only recourse is to continue using an older version of the product which included the feature.
We will often estimate the cost and timeline for services before rendering them. These estimates represent our best guess, but may be unreliable. These estimates are non-binding and create no obligation.
Pay Only When Satisfied
Payment is not due until delivery. If you are not completely satisfied with the any aspect of the service (including the product, timeline, price, or anything else), you are not expected to pay us.