Showing posts with label Agile Software development. Show all posts
Showing posts with label Agile Software development. Show all posts

The "How To Bible" for a Non Tech Person How To Supervise Outsourced Software Development

The decision to outsource a new application development often times seems like a rather daunting tasks for a business executive who has never supervised outsourced application development.

The simple truth is that not all companies have the In House tech staff who is experienced in organizing and supervising outsourced software development.

Fortunately the proper way to be successful when outsourcing software development is really not that complicated. Below is a 6 step list which, when followed, should ensure that your outsourced software development will no go off the rail.

Please note that the steps below are only applicable once you have selected the right outsourcing provider. Obviously, if your selected outsourcing partner does not deliver on the technology it can get rather tricky.


Step 1:  Requirements Management and Audit
You start with the most important item first. A detailed analysis of the requirements is key. Each capability of what the software needs to do has to be properly documented. Additionally you have to assign the proper permissions, (edit, read, modify, delete and so on) to each user level which is authorized to access the data relevant to that function and or feature. There is a good chance that your Outsourcing Provider will have a Requirement Manager on staff who will guide you through the process. If not...assign a member of your team that responsibility. Once you have the requirements down schedule meetings with the Lead Developer or Team Leader and run through all the requirements to clarify any misconceptions which might arise. A well thought out requirement list will ensure that your application has all the features you need while avoiding excess development time which might arise due to changes and/or additions which become otherwise necessary.

Step 2: Testing Tools
Once the outsourced software development team starts working testing of what is produced becomes the most important task. The Quality Assurance needs to stay on top of the development process to make sure that the development is correctly aligned with the requirements. Gantt and/or waterfall charts should be used to structure the development process into easy to follow steps. (the sprints). Your outsourcing partner will have a dedicated QA team (Quality Assurance). However, you or the person tasked with supervising the development will need to make sure that testing is done in accordance with the progress the developers make. It goes without saying, testing should never be done on the live app...a dedicated testing environment is something your outsourcing partner should have set up for the entire development process.

Step 3: Timelines
Besides the quality of the product timeliness of the development effort should be your second most important priority. You want your development effort to stay on track. As such it is vital that prior to development the estimated time and allocation of resources is done. Reputable outsourcers will provide detailed estimates as to how long the development of certain milestones (broken into sprints) will take. By tracking actual hours spent versus the estimate you will be able to easily ascertain  if the project is on schedule. Reputable software development firms will have that process down by using specific project management software which makes them accountable based upon the  hours pent versus a prior estimate.

Step 4: Consistent Feedback
It goes without saying...your outsourcing partner needs to know what you think. You need to regularly review how the software works and test it. Based upon your testing you need to provide feedback as to what features are to be amended and changed. It is much easier to change requirements early on while the particular feature is still under development. If you do not have the time to engage in regular testing assign the task to someone else and make them responsible to provide the needed feedback.

Step 5: Solicit Advise From Your Outsourcing Partner
You might have very specific ideas as to what the software needs to do. However, often times the outsourcing provider might have some very valuable ideas as to how to build a "better mousetrap". Technology moves at rapid speeds and there is a pretty good chance that your outsourcing provider has a good idea of how to improve upon desired functionality without adding much to the development effort. By cooperating and soliciting feedback throughout the process  you will end up with a better product; without necessarily making it more expensive.

Step 6: Test After It Is All Done
There is nothing more disruptive then having a new software release out with your customers and/or staff and then realizing that there is a problem. It is never good to roll back a software release. The problem might be with the functionality or feature or with platform compatibility. Therefor you will need to make sure that once you have the final product ready to go that it is performing as required and that it works on the platforms your business needs to support. (various browsers and operating systems, desktops, tablets and phones). The above might seem trivial...but I have personally encountered software releases where quite a few remote team members of a customer were still working on XP and Vista  even though the requirements were to be compatible with Windows 7 and up. Proper beta testing  can avoid disruption in business processes prior to making the software operational.


Supervising outsourced software development is easier than people often times think. By following the steps outlined above there is a pretty good chance that your project will go off without a hitch.













Does Agile Makes Software Development More Expensive...Yes And No...Here Is Why

I am in the business of providing outsourced software development. When we design the requirements of a new software development a Requirement Manager will go through the entire project with the client and find out what specifically the client needs.

Often times the client is not necessarily aware of all the requirements it has when the project starts. There are general ideas,  but sometimes the general concept has not been completely thought out.

A good Requirement Manager can be extremely beneficial in a situation like this. He/She will think along with the client and sketch out in technical terms what functionality the developers have to code.

The requirements then form the basis of the development model.

In a traditional development model (Gantt Charts and Milestones) at certain predetermined intervals the clients get a chance to review an interim product built and, once approved, the next step of the product will be developed.

The Agile development is different in so far that the client stays much more involved in the development. There is a constant back and forth (usually daily) with questions raised by the developers (typically through the Project Manager) and being answered by the client.

For a more in depth explanation of what an Agile project development looks like see here

Testing of certain functionalities happens much more frequently and often times unrelated development steps are being conducted at the same time.

The whole idea of an Agile  project development (versus Gantt and Milestones) is to make the client more involved, thus enabling  him to constantly improve upon the final product. Nonsensical development is supposed to be recognized earlier on..thereby reducing 'errand" development time.

 One can argue  which approach is better. I certainly feel Agile is the way to go.

One inherent side effect which develops out of the Agile Project Management approach are changing requirements. What typically happens is that the more the client gets involved in the development process and gets to play around with the product...the more the client gets a feel for what the final solution should truly look like under real life conditions.

Consequently a client will update the requirements. Features get added and / or amended.

Needless to say...the adding of additional features makes the development more expensive. Every time an additional feature is added more hours have to be paid for.

Therefore the argument has been made that Agile is "more expensive".

I  wholeheartedly disagree with that opinion and, as a matter of fact, believe that an Agile approach will make the development cheaper.

That might seem counter intuitive at first..but here is why.

It is a simple fact that the Minimum Viable Product built ( MVP , the first development) is always just the first step to a more final product. As soon as the MVP is out and people start using it there is feedback coming in, suggesting updates and improvements.

Using an Agile approach ensures that the MVP is a much better solution than the MVP built using a simple Gantt based approach.

Precisely because the client has been more involved in the development and was able to add and/or update features while development was still going on less actual software development (= less developer time)  had to be done.

It is obviously much cheaper to add a feature at an early stage (or amend functionality) when there are less interconnections to be worried about. By completing these changes earlier in the project a significant time saving can be accomplished versus changes to a released  Minimum Viable Product built.

The Agile Development approach delivers a reduction in development time  because the product release will be much closer a a more  "More Final Product".

Using a Gantt development approach the costs to bring a Minimum Viable Product to a a more Final Stage Product are often times significant.

Anyone who has been in the Software Development Business long enough can tell stories where entire functionality modules were just missed...and had to be created after the fact (the MVP built) at great expense.

Using Agile a better MVP gets created, one which much  more resembles a Final Product. Because the  MVP  built using the Agile approach is better  the overall development costs are reduced.















The Dirty Truth - Your Outsourcing Team Might Be To Young ?

One issue I  frequently discuss with corporations which have outsourcing relationships with other vendors is that they are often times not happy with the performance provided. There is not one single performance matrix which is leading corporations to that conclusion but rather this is often times an across the board assessment of the relationship. The attitude is that it works, albeit not great.

Some of the frequently mentioned  Key Performance Indicators which lead to that assessment are :

  • Development Sprints take to long to completion
  • Sprints are simplified by reducing the number of sub tasks
  • Q&A takes to long
  • Average time for bug fixes  

I am often times amazed that the prevailing mindset seems to  be that this is just "fine"  and  lesser performance is to be expected when outsourcing. After all...pricing is low enough that it does still make economic sense.  (and I am sure that is true for a lot of outsourcing relationships).

Let me perfectly clear...I am the first one to admit that there is a productivity gap between an onshore and offshore software developer.

What is important to realize though is that with familiarity the productivity gap will start shrinking right away. The actual gap remaining after a month or two month is subject to debate...in my opinion it is not uncommon that the gap will be eliminated completely, but as I said...it is subject to debate.

As such the question needs to be looked at why the feeling is so often that the quality of the work is just not great. In my experience and when discussing the outsourcing strategy I usually learn that in situations like the ones described above the outsourcing vendor is looked upon as a cost center.

The most important factor in negotiating any outsourcing deal is most often the hourly rate or team rate being charged. Corporations will negotiate to get the lowest rate to realize the most savings.

The strategy does of course makes sense to the corporation...but the flip side of the coin is that it does then lead to shortcoming in the composition of the development team.

A low rate will lead to a team which is predominately staffed with junior developers, supervised by a few senior guys. The problem with that approach is that the Junior developers are afraid of the power wall...they lack the authority and confidence to challenge their immediate superiors or anyone from the client side.

Consequently the back and forth which ultimately results in a more productive and informed process is lacking.

Of course not every corporation is going to willingly spend more money on its offshore development team to change the mix up of the team. It might be a good investment though...just exchanging one or two junior developers with mid-level developers might create the bridge the team needs to overcome the power wall, both internally and externally.

If the budget is set in stone another option is to exchange 3 junior against 2 mid level developers (given the team size allows for it). It should be cost neutral  but it is my experience that the change in team dynamic will boost productivity and improve the overall KPI's despite the reduction in team size.

















Agile Project Management...Is Your Software Outsourcer / BPO Firm Using It ?....

One problem I frequently run into when discussing project guidelines for outsourced software development  is that most of the clients  are well familiar with Gantt charts or Waterfall charts. As such they prefer to look at the project guidelines, timelines and milestones based upon those  charts.

Nothing wrong with that of course...but the software development world has moved on and at least the better companies are now mostly using an Agile Software Development set of principles. The concept of an Agile environment is that it is much more "free flowing" and not bound to the traditional milestones and tightly defined guidelines which are being used in a Non-Agile environment.

The challenge is how to provide the accountability to the client  (the ones who pay the bill) while harvesting the advantages the Agile environment can deliver.

The Agile Development environment is based upon the following 12 principles:


  1. Customer satisfaction by early and continuous delivery of valuable software
  2. Welcome changing requirements, even in late development
  3. Working software is delivered frequently (weeks rather than months)
  4. Close, daily cooperation between business people and developers
  5. Projects are built around motivated individuals, who should be trusted
  6. Face-to-face conversation is the best form of communication (co-location)
  7. Working software is the principal measure of progress
  8. Sustainable development, able to maintain a constant pace
  9. Continuous attention to technical excellence and good design
  10. Simplicity—the art of maximizing the amount of work not done—is essential
  11. Best architectures, requirements, and designs emerge from self-organizing teams
  12. Regularly, the team reflects on how to become more effective, and adjusts accordingly



A practical problem of an Agile development is that there are really no Milestones the teams are working towards. As such there is no firm date which can be given so that the customer can review a an interim work product (milestone).   


A practical solution to this dilemma (and one we use internally) is to still provide Gantt charts but use an  Agile environment in House.  The process has to be of course managed properly...but if done well it is entirely  possible to utilize an Agile environment while also providing the form and accountability the client is looking for.  

A great article which goes into details as to the way an Agile Development Environment works can be found below.