Methodology

We rapidly prioritize tasks, divide responsibilities efficiently and time-box every element. We revise and correct our course continuously through Sprints and iterations. Providing our talented developers with organized and efficient leaders is one of the keys to our success.
During complex projects, teams working with this methodology hold daily Scrum meetings, keeping track of done and pending tasks with the best available project management tools and software.

During these brief and efficient meetings, we focus on the 3 essential questions of Scrum:

1. What did you accomplish since the last meeting?
2. What are you working on until the next meeting?
3. What is getting in your way?

In short sprints, our teams are able to continuously re-prioritize tasks and reduce the product backlog with consistent efficiency.

Agile is our standard practice for services-oriented projects, code and design deliverables. Our teams employ it when the client’s involvement is crucial for development or when the product’s features and functions are not set on stone and there are margins to improve and adapt. Through small incremental changes we test and advance swiftly towards the end product while remaining flexible to evolving circumstances and initial plan modifications.

The backbone of our standard of excellence are DevOps principles. We trust our talented developers, we embrace the innovation they bring, we encourage transparency and build cross-functional teams that never lose sight of the KPIs or the passion for achieving them.

For big-scale projects in which both software development and operations teams are present, we use DevOps practices to allow for smoother collaboration and reduced risk down the way. For this, we focus on:

• Telemetry & Alerting: We use Application logs and Metrics to measure all useful data flowing through the system and keep track of every type of error present, as well as inform us of the current state of the system. Once this is done, we establish necessary alerts to inform us of events that need diagnosing and fixing.
• Automated testing: We automate every test we can to ensure the code works perfectly after implementing any change, saving valuable time that would be wasted on manual testing.
• Continuous deployment: By using code repositories and branching processes we make sustained incremental changes to lower the risk and impact of each change. This enables us to quickly roll back on ineffective changes that would otherwise halt the entire process.

By working closely with our clients, determining essential features and understanding the core functions of the product, we are able to deliver complex projects on tight schedules, keeping the code base simple and response times to a minimum.

Our Lean teams stick to the 7 principles of Lean methodology:

1. Eliminate waste: Avoid any activity that doesn’t add value to the finished product. It’s essential to avoid unrequired features and time consumed crossing organizational boundaries.
2. Build in quality: At all costs, avoid queuing defects to be fixed. We employ techniques to minimize mistakes such as Test-Driven Development, or Pair Programming.
3. Create knowledge: We reflect on the learnings of each iteration in development to better understand the product we are creating and the needs and interests of our stakeholders.
4. Defer commitment: Schedule irreversible decisions to the last possible moment. This allows you to use change-tolerant and flexible architectures.
5. Deliver quickly: By tracking the amount of “points” of functionality our teams deliver in each iteration, we are aware of the average velocity we manage for each project and organize our shippable solutions around it.
6. Respect people: We don’t micromanage our talented teams or demand impossible things from them. We trust their expertise, and they respond by working with motivation on a healthy environment.
7. Optimize the whole: Lean is not about quick and easy solutions, every instance must also build for the long-run. Short-term solutions create vicious cycles which deter the project exponentially such as writing sloppy code or overloaded testers.

We prioritize user involvement and feedback to create products with great interaction, excellent interface and frictionless user experience. Our clients can see every step of the development to have a vision of what the end-product will be. We rely on the Prototype model for intensive end user interaction products. Online systems and web interfaces are ideal candidates for this, as well as projects when there’s a need for minimal training/ knowledge for the final user.

For this, we follow the 6 classic steps of prototype practice:

1. Requirements and analysis: We define the requirements of the system in detail with interviews and thorough functionality questions and expectations.
2. Quick design: A preliminary design is made, with no coding or programming involved. In this stage we define the feel of the product with the client.
3. Build prototype: Once the design concept is approved we move onto building the first prototype, with basic functionality and only the core features.
4. User evaluation: The prototype is tested by different users to evaluate and identify strengths and weaknesses. These range from basic functionality requirements to esthetic choices. Comments, suggestions and every input is taken into account and compiled.
5. Refining prototype: Using all the information gathered from the user evaluation, a more advanced version of the prototype is made and presented again to the user. This phase is where most of time and resources is invested as many iterations are often necessary to achieve a remarkable product.
6. Engineer product: Once the final prototype is approved, it goes through a series of quality controls and strict evaluations before it’s turned into the fully functional final product.

When working with Extreme Programming, we follow 12 of its most common practices:

Fine scale feedback
•     Pair programming: Code is created by two people working on the same computer.
•     Planning Game: With the use of index cards we sort and prioritize user requirements.
•     Test Driven development: Short development cycles where tests are carried out before writing the production code.
•     Whole team: Feedback loops are established between every member of the team.

Continuous process
•     Continuous integration: Bite-sized components are developed, tested, fixed and integrated before moving onto the next.
•     Design improvement: Removal of duplication, increasing cohesion of the code and lowering coupling.
•     Small release: Releases are kept small and simple to minimize roll backs and error detection.

Shared understanding
•     Coding standard: In matters of Formatting, Code structure, Naming conventions, Error handling and Comments.
•     Collective code ownership: Everyone at the team is allowed to modify and improve on any source code.
•     Simple design: A design that runs all the tests, contains no duplicate code, states intent clearly and has few classes and methods.
•     System metaphor: Capable of explaining easily the system design to new people.

RAD allows us to respond with extreme malleability in such scenarios and evolve our design as we gather more knowledge about the product’s needs and requirements.

Advantages of using RAD on specific projects:

1. Measurable progress: Iterations, components and prototypes can be measured as small segments to keep track of progress.
2. Productive code: Using working code to illustrate examples allows to visualize concepts that would otherwise take days or weeks.
3. Compartmentalization of system components: By creating functional and independent components, risk is reduced, and each element remains easily modifiable.

4. Adaptability: Iterating and prototyping potential concepts throughout development allows for flexibility to changing circumstances.
5. Early integration: By integrating components early, errors or complications can be identified quickly, forcing immediate resolutions.
6. Rapid and constant user feedback: Obtaining relevant user feedback is essential to evaluate the current state of the software and make necessary changes as soon as possible.