Software is always built on other software - your dependencies - and the dependencies that you choose have a considerable influence on your success. Choose the existing technology that you know, and you have good predictability, but you might not produce a great product, or it might take too long to finish. Choose a hot new technology, and it's harder to predict what will happen. Maybe the benefits will be great and you'll finish faster (ASP.NET vs old ASP...). Maybe things won't be as good as promised (insert the name of a technology that you were "disappointed with" in the past).

Or maybe it's not finished when you need it. Welcome to the wonderful world of co-development, where you are depending on features that aren't implemented yet. How do you reduce the risk of features/APIs not showing up, or being substantially different than you expected?

Well, the first (and best) way to reduce this risk is simply not to do it. If you only depend on features and APIs that are currently available, you know they are there.

If you can't wait a full release cycling, then perhaps you can take some sort of incremental approach, where you plan to use feature <X> but don't *commit* to using it until its actually there. My preference would be an agile approach (such as Scrum), so that when feature <X> shows up, it's actually finished and working.

That's really just the same thing I said first - don't take on the dependency until something is done.

But what do you do if you really need that feature - if your plans would be derailed unless the other team finishes the feature? I have four things in mind that can help:

Accept the Risk

First, you have to accept that you are taking on risk. Software scheduling beyond a period of a month or two is not only an unsolved problem, I believe it isn't a tractable problem. Decades of project slippage have demonstrated that, and we should just embrace the uncertainty involved rather than trying to "do better".

Note that while there are teams out there that can give good estimates for tasks in the next month (and perhaps up to two months), you can't assume that you are dealing with such a team. There are many teams who are essentially unpredictable even in short timeframes.

Understand the Risk

Second, you need to understand the risk. This will require you to work with the team that's building whatever you are needing. You need to understand where your feature ranks in the things that they are doing. It might be a feature that they absolutely have to have to ship, or it might be a "nice to have" feature. You need to understand this. It's closely related to how close your requested feature is to their main charter. You do not want to be the outlier group amongst all their clients, the customer they don't want to have.

You also need to understand when they're building the feature. If it's very early in the cycle, then it's likely to get done. If it's late in the cycle, it's less likely to get done.

If they don't think of features in this way and/or are working on features in parallel, it's more risky.

It would also help to understand what development methodology they use, and their history of being done when they guess they will be done.

Plan for Mitigation

What are you going to do if things don't work out, if the feature is late or is cut? Even in the best organizations, people get married, are out for months on medical leave, have accidents, or leave to form their own companies.

What is your group going to do when this happens?

Track the Risk

In an ideal world, the group you depend on would give you regular updates about the feature you're waiting for. And some groups do do this, but it's your risk, and you're going to need to stay on top of it. The details of that depend on the groups involved.

Accept the Outcome

If things work, great. But if the feature doesn't show up, remember that you were the one who accepted the risk in the first place.