During the 1990s, many development organizations successfully made the transition from mainframe development to client-server development. Here are some of the lessons learned from these organizations:
Mainframe developers generally have acquired much better data center operations disciplines than their client-server brethren. Make sure these disciplines are not lost when transitioning to a client-server environment. Just because a portion of an application runs on a distributed end user desktop rather than in a glass house data center, the same application testing, version and baseline control, error checking and recovery, and security needs to be built in to enterprise-wide applications, regardless of where they ultimately execute. Developers who grew up in the client-server world developing engineering or personal productivity applications where a software error affected only one or a few users, versus hundreds or thousands, tend to lack some of the mainframe development disciplines mentioned above.
Client-server developers often are accustomed to operating with greater flexibility, allowing them to respond to new customer requirements in a more timely fashion. Part of this is because they don't always carry out all the mainframe disciplines listed in the first point above. Part is just because client-server development tools and environments often affords better productivity. The challenge in a mainframe to client-server transition is to combine the best of both environments.
When transitioning developer organizations, make sure to get everyone involved. This means not only the developers but also the system administrators, database administrators, even the office administrators and the receptionist . Even those not directly involved in a transition of skills should be aware of the transition and clearly understand the business reasons that are driving the change to the new technology.
Most organizations transitioning to a new client-server development environment do not get rid of their mainframes, at least not on day one. This means that mainframe developer experience will remain an important skill in order to continue maintenance of legacy applications. In addition, most of those new client-server applications will probably require one or more interfaces to legacy mainframe. There is no better way to develop a client-server to mainframe interface than to have the developer who wrote the original mainframe application on your client-server team.