Here at Kizoom we use Agile or XP software engineering techniques to build our products and services.

Traditional 'waterfall' approaches to software development, with long timescales for requirements gathering and delivery, rigid specifications, and elaborate methodologies (often accompanied by a confrontational approach to managing further change), just don't work in a sector where the technology is subject to rapid evolution, and where the application requirements and affordances are still emerging. (In fact they don't even work very well in many traditional IT sectors!).

There are however still many important disciplines that need to be maintained to deliver 'industrial strength' software and to evolve it over time, notably in the areas of team communication, design & review, testing and deployment.

Agile development aims to combine the rigorous software engineering techniques needed to build working systems with the flexibility needed to meet customer needs - especially in an environment of continuous business and technology change. Thus it emphasizes many proven 'traditional' practices for achieving quality, but advocates a more modern process for requirements capture and business negotiation. Advances in software and hardware have qualitatively affected the nature of development, in particular the availability of powerful tools, high levels of abstraction in OO languages, and extensive component libraries: agile development precepts reflect this, along with the insights from a wide collective experience of real world software development.

Kizoom has been using Agile development since the company started in 1999 and as a result has repeatedly been able to be first to market with robust, scalable applications involving complex technologies and dependencies.

• Know what's needed, say what's possible
  'Customer focused requirements capture' is based around use-cases and customer participation to set priorities and understand business tradeoffs. Implementation performance is monitored and continuously fed back into the planning process to improve estimating and obtain realistic delivery dates.
• Small steps
  The careful management of technology risks; key techniques are the use of prototyping and iterative development, and the use of continuous integration to avoid system integration bottlenecks.
• Many heads, more eyeballs
  The extensive use of continuous peer review to improve design and code quality - and to spread knowledge. The large majority of our application work is done though pair programming. This helps to ensure we make the right design tradeoffs and have a widely skilled development team.
• Write once, test many times
  A focus on built in code quality to get this is done by a systematic, disciplined approach to testing. Our aim is to get it right first time. We write formal tests for every component we build, and run a complete regression test whenever we deploy. This also makes it possible for us to aggressively refactor our code over time to improve it, without breaking our services. We use a carefully staged deployment process.
• Be smart, be lazy
  Use the best available tools for development, code management, and software builds, and use powerful, proven software languages and platforms. This allows us to aggressively refactor and revise our code to evolve it to be the best possible product.