I frequently take on custom software projects... you know, someone needs a web application to do X, Y, and Z and there just isn't anything already on the market that does the trick.
But the truth about software development is that it takes a lot of time and is very expensive. So it isn't unusual that I'm asked to design the app in such a way that it can be re-sold to other people that might have similar needs.
In other words, one client will bankroll the costs of the custom software, but they'd like the option to recoup those up-front costs by re-selling later.
If you get asked to do software like this, here is my advice...
You have two choices.
- You can design for the potential mass-market first, then customize an instance of the application for the specific needs of your paying client when you are done.
- Write for your paying client's needs first, then extend and expand the initial design to meet the likely requirements of other clients later.
Forget Option 1.
Look... If you are very experienced with reusable platform development, you have a lot of time for design before you start writing your code, and you have a large team then you might actually consider option 1. Otherwise you are about to embarke on a dissaster.
You only have one known customer and you are only guessing that there could be a wider market out there for the product... a product that doesn't yet even exist. You can make some guesses about your phantom market's needs, but stop kidding yourself...
It is hard enough to get decent requirments out of known customers. Expecting to find usable requirments from a phantom market is just moronic.
I know, your paying client really belives there is a market for the product. They might even be right. But just nod your head and say you'll write something they can re-sell. Then forget about any customer other than the one who has commissioned your project.
Take Option 2!
Assume that the customer bank-rolling your project is the only customer that will ever buy the product. Not only is this probably true, you also have to keep in mind that most custom software projects fail even when you only have one customer to contend with.
Your primary goal is to make a successful product that can get the job done. If you can't produce software that does the job for your paying customer, then you aren't going to have a reatil market to worry about anyway.
Despite how careful you might be to gather good requirments, create a fantastic design, then code you ass off... you will not know if your software can do the job until you deliver it to a customer and get to see it succeed in a production environment under regular usage.
If you are successful, and your software meets your paying customer's needs... then can you start thinking about a potential retail market.
The good news is that by the time you get a workable product for your paying customer, you've probably already built an application that is likely to meet the majority of your potential customer's needs too!
Things to keep in mind for version 1.0:
- Use an agile process. You don't have to use a formal methodolgy, but stick to the agile ideals. Code the bare minimum you can get away with, deploy it to your paying customer for testing, get their feedback, then go back and code a little more.
Repeat this process until you get all of the 1.0 requirements implemented and deployed. I also suggest that you price your deliverables this way too. Embrace your customer's tendancy to feature creep and shift the requirments as you progress towards the 1.0 release. Be willing and eager to change the design as you progress towards 1.0.
If you are not directly employed by the paying customer, you do need to make sure you are getting paid immediatly after each delivery, and that you keep the customer informed of the exact price of the changes they request at each iteration.
- Brutally cut everything you can from the customer's requirments for early iterations. Keep it as simple as possible and implement only the absolute bare essentials.
Your client will insist that some fluffy features are "essential". Ignore them and cut those features anyway. You don't have to tell the client you are cutting the features, just tell them you have them scheduled for a later iteration... even if you don't.
As you deploy iterations towards 1.0, your client will forget about a lot of those fancy features, and you will start to get an idea as to which things are "really" important to them and which ones aren't... all without having wasted time writing the stuff you don't need.
- Avoid over-architecting your application. It is tempting to layer and componetize everything and follow all those best practices and academic OO techniques. You may also be tempted to split the app into a dozen different assemblies too.
For version 1.0 you want to deliver the minimum necessary features that get the job done, and you want to deliver it as fast and as cheap as possible. Where OO techniques and best practices will reduce the effort it takes to write your 1.0 code, go for it... but if you can't say for sure exactly how your architecture is getting you to the finish line then scale it back.
- Avoid 3rd party code as much as you can. This includes 3rd party frameworks as well as 3rd party UI components and code libraries. If you cannot produce an essential user facing feature with a built-in component or the stock framework libraries AND you cannot write the code for that user facing feature fairly easily... then you can consider using a 3rd party component.
If you do use 3rd party code, be sure you have a cheap or free license to redistribute it. While you aren't yet worried about a retail market, you don't want to trap youself by using stuff you can't legally redistribute.
- Don't worry about making everything configurable via online admin tools. Sure, it is nice to allow the client to use an admin tool to change page titles and text without having to change code... but remember that each and every configurable feature adds complexity to the code and is a potential bug.
Also remember that admin tools are also features that you have to design, test, and debug... but they don't add much value to your application's core functionality directly. These tools can wait until a later version after the core application is deployed and proven successful.
- Stick to the simplest data access mechanism that meets your needs and don't worry about supporting multiple database platforms. Pick a database platform that your paying client can live with, and stick to it. In your code though, you also need to make sure that it can adapt to changes in your database's design without you having to spend too much time fixing up existing code.
- If there is one area you have to totally kick-ass with in version 1.0, it is reporting. If your application has any reporting needs, and most do, you need to be sure you start off with reports that dazzle your customer from day 1.
Be sure the reports are pretty, interactive (sorting, filtering, paging), and most of all printable.
Reporting is the part that your paying customer's management will use the most, and they are the ones that hold the purse strings. You HAVE to knock them dead with killer reports!
Later, if you get a retail market for your app, it will be the reporting features that make or break the sale.
After version 1.0: getting to the retail market:
I can't tell you how to find and convince other people to buy the application.
What I can tell you is that if you have a 1.0 product that makes your initial paying customer happy, then the odds are good that you also have an application that other similar companies or individuals will be pretty comfortable with too.
You can probably make a few minor adjustments and take 1.0 to the market as is; and I highly recommend that you get it to market as soon as you can with as few changes as you can.
Why the rush?
- You want to recoup the sunk costs of the initial development as soon as possible.
- You need some real clients so you can guage if there are additional requirments that need to be addressed in the next version that you don't already know about.
- You can learn from potential clients that decline to buy your application too, just politely ask them why. Is it too expensive? Do they have some competing software already in place? Does your app lack essential features?
So... what about 2.0?
If 1.0 was successful with your paying customer, you will likely be heading towards 2.0 even if you don't have a 3rd party market... but by now you should actually know if you have a 3rd party market or not.
If you don't have a retail market then you should consider abandoning the idea of having one later. This will keep the costs low for your paying customer and reduce the scope of your 2.0 project. You can concentrate on enhancing the application for your paying customer's more advanced and ambitious needs as well as shoring up any weaknesses in your 1.0 application's architecture without complications from other customers.
If you do have a 3rd party market, you will want to trim out as many new features as you can and stick to just the ones that are essential to your retail market and paying customer's needs... and I mean essential here... skip the nice-to-have stuff still.
If there is a retail market buying your product though, you should keep in mind that you have two kinds of customer. Users and management are are one customer, but don't neglect other developers employed by your customers that may need to customize or extend your application. Make sure 2.0 has good developer documentation, a well documented and consistant API, and consider exposing APIs over web services too.
Either way, 2.0 should be about fixing up sloppy code in 1.0, improving the underlying framework's design with an eye towards supporting all those new features on your client(s) wish-lists. The goal is to re-design, re-architect, and re-code now to support easier and faster development going forward.
In 1.0 you will have identified some fundamental architectual and design mistakes. Fix these in 2.0 to get it out of the way. If you don't, you'll just make it a lot harder to expand your application to meed new requriment later.
And that's it... once you get to 2.0 you will know far more about what you need to do in 3.0 than I do. 3.0 should be sitting on a core application that does a good job, and has been re-designed to be easy to code against. So 3.0 is where you can unleash new features that impress users and improve their lives.
