Ever wondered how companies like Facebook or Google can develop new working features at such a crazy pace, while others take forever to release shaky software?

Answer: these companies are using an Agile approach that includes state-of-the-art technical practices. Here are those practices.

The problem:

You’re never quite sure that the software you’re building actually works. Your software routinely has a lot of defects that are expensive to find, because that requires a lot of manual work from the testers. Even after you find the defects, fixing them is also very expensive, because the system’s design continuously gets in the way of developers as they fix it. Some defects even come back sometime after being fixed.

With our help, you will:

• Spot most defects as soon as they happen, when they’re orders of magnitude cheaper to fix.
• Run your tests all the time at zero cost, to find problems before they impact on customers.
• Have “executable documentation” that is very detailed and always in synch with the code.
• Make it easier to bring new developers up to speed while minimizing rookie mistakes.
• Build a system that’s easier to change extremely fast, because the tests provide a great safety net to developers.
• Build a better-designed system, because the developers are guided by the tests in designing code.

The problem:

Manual testing is very expensive. Worse, if you find a bug during manual testing, you have to fix it and then re-do the testing, doubling the cost. Also, it’s common for customers (even customers inside your Company) to be dissatisfied with the end result, even if you spend a lot of time and money gathering detailed requirements.

We help you with:

• Reduce expensive manual testing in favor of cheap automated testing.
• Run tests all the time to spot problems in development *and* in production.
• Develop the system that your customers expect and reduce communication problems.

The problem

As long as every developer in your team is working on his/her computer, they all tell you that things are fine. Then it comes the time to put everybody’s work together, and all kinds of problems suddenly come up. The team takes forever to integrate and deliver the software. You’re nearing a deadline, so this is the worst possible time for this to happen. The project seemed on track until a few days ago, and suddenly now it’s overtime and over budget, and the customers are getting impatient.

We help you with:

• Spot integration problems as they happen, when they’re still cheap to fix.
• Get a report on the state of the project that you can actually trust.
• Collect detailed project metrics, so you’ll always know what’s happening.
• Lower development costs with minimal investment.
• Improve developers’ morale by letting them trust that the system works.
• Open the road to automated testing and other more advanced techniques.

The problem

Your team is working with modern technologies, but they still seem to have all the problems of the old technologies. The system is brittle and difficult to change. When the requirements change, the team has real trouble adapting the software to the new requirements.

We help you with:

• The system gets cheaper to grow and change even in the face of changing requirements.
• The team finds it easier to learn and communicate the internals of the system.

The problem:

Your development seems to slow down as time passes. The developers are complaining that they have a lot of “legacy” code that’s difficult to work with. They’re always asking the impossible: to stop developing new features and “do it right”, maybe by rewriting the entire system. This cannot be afforded, but things are deteriorating: every change seems to introduce more bugs and to take more time than the previous change. This is called “technical debt” – just like financial debt, it sinks money into “interests” on previous investments. At one point, adding new features will end up costing more than the features are worth, and you’ll have to dump the old system and start again from scratch, at an extremely high cost.

We support you with:

• Keep the cost of new features flat as the system evolves and requirements change.
• Radically reduce the cost of fixing bugs over time.
• Improve developer morale and stop them from asking for time to “fix the system”.
• Never have to dump large parts of the system and rewrite them from scratch.