Agile Development Process

Our web app development uses an agile, Scrum-based workflow, tailored for effective work in a distributed team and accommodating clients across different time zones.

Projects are executed in small iterations, or "sprints." At the end of each sprint, we deploy a stable, working project to the server.

Sprints vary in length, typically one or two weeks, depending on project specifics. The duration is fixed, and deployment always occurs on the same day for each sprint.

Our workflow is meticulously optimized to ensure:

  • The achievement of a stable product by the end of each sprint.
  • The ability to change product concepts in the middle of the project.
  • We are never hindered mid-sprint, even if client correspondence is delayed.
  • Seamless continuity in development from one sprint to the next.

To manage our repositories effectively, we incorporate Continuous Integration and adhere to the git-flow approach.

At the conclusion of each sprint, we engage with the client through a call to demonstrate the project's progress. Within the sprint, our team conducts brief daily calls to maintain alignment and momentum.

Sprint Phases 

Our sprints are structured to navigate through several distinct phases: 

  • Preparation: This is where we define and assess tasks, setting the stage for what needs to be accomplished.
  • Development: Our team dives into coding and crafting designs during this phase, bringing the project to life. 
  • Stabilization: Here, we focus on testing and debugging, ensuring everything runs smoothly. 
  • Deployment: The final step is to launch the stable version of the product onto the server. 

To accommodate the variable workload of our developers during the Preparation and Stabilization phases, we've designed our sprints to overlap. This ensures that as one sprint's Development phase concludes, the next sprint's Development is already underway.


In the preparation phase, our analyst undertakes several critical steps to set a solid foundation for the sprint: 

  • Client Consultation: The analyst engages with the client to gain clarity on the requirements for each task.
  • Technical Specifications:A comprehensive technical description for each task is crafted, sufficient to guide full implementation.
  • Resource Assessment: Ensuring all necessary materials such as designs, HTML/CSS code, and texts are prepared and accessible.
  • Task Estimation: Tasks are sized using the t-shirt sizing method (XS, S, M, L, XL), with the aid of our historical data engine to forecast the time investment needed for each task.
  • Sprint Formation: The analyst assembles the sprint, ensuring that:
  • The workload is achievable within the sprint.
  • Developers have a full schedule.
  • Work distribution among developers is equal.
  • Extra tasks are available to developers to maintain productivity in case of any impediments.

This meticulous process is repeated throughout the project's lifecycle. We segment it into defined phases with explicit timelines to guarantee the punctual preparation of upcoming sprints. 


Our testing process is a two-pronged approach to quality assurance: 

  • Feature Testing: Concurrent with the Development phase, Quality Assurance (QA) specialists focus on individual features. They validate that each new feature operates exactly as intended. 
  • Product Testing: During the Stabilization phase, QAs conduct comprehensive testing on the entire product. This is to ensure that the integration of new features hasn’t disrupted existing functionalities. 

If bugs are identified at any stage, our developers promptly address them, implementing fixes in the release branch before proceeding with updates to the staging server.  

In our process, sprints overlap during the stabilization phase. Quality Assurance (QA) teams conduct regression testing, while developers begin the next sprint. If bugs are identified, developers address them before returning to the ongoing sprint tasks.


Deployment, in our workflow, is actually not a phase—it's a celebratory milestone. It's significant to highlight because it represents the culmination of our efforts. Achieving deployment is our definitive objective, marking each sprint's successful conclusion and the value it adds to the overall project.

Hot Fixes

It's unrealistic to claim that every process unfolds without a hitch. Unexpected situations arise, sometimes necessitating immediate action, irrespective of our current sprint phase or even our team's rest periods. 

In such instances, we initiate a special, compact ad-hoc sprint that runs concurrently with our scheduled sprint. This ensures that urgent fixes are addressed without disrupting the ongoing development flow. 

Here’s how we handle hot fixes:

  • Implementation: Any urgent new feature is developed on top of the latest production codebase, rather than the current development branch. 
  • Testing: Once implemented, the changes are pushed to the staging server for thorough testing. 
  • Deployment: After successful testing, the hot fix is deployed directly to the production environment. 
  • Integration: Finally, the hot fix is merged back into the development branch to maintain consistency across codebases. 

Hot fixes are generally minor and can be integrated without significant adjustments to the current sprint. However, occasionally, if a more substantial issue arises, we may need to reschedule less critical tasks to the next sprint to accommodate the urgent fix. 


Within our workflow, we have designated roles that are integral to our operations:

  • Analyst: This role involves dissecting project requirements, interfacing with the client to clarify objectives, and ensuring that the development team has a clear understanding of what needs to be accomplished. 
  • Developer: Developers are the backbone of our technical execution, transforming project specifications into functional code and user-centric designs. 
  • QA (Quality Assurance): QA specialists are tasked with the critical role of ensuring that the product adheres to the highest quality standards, rigorously testing features and the overall functionality to identify and resolve any issues.

In our team, management tasks, crucial for coordinating with external teams, are not assigned to a specific role. Instead, an Analyst or a lead Developer takes on these duties. This approach keeps our team aligned and on track, meeting project milestones effectively and maintaining agility for each project's unique needs.

Task Management System

Trello stands as our chosen task management system, its intuitive interface and robust features enable us to meticulously plan sprints, forecast task durations, and monitor time investment. Additionally, its user-friendly dashboard allows clients to observe the progression of their projects in real time.

In scenarios where clients are committed to using alternative systems such as Jira or Asana, we maintain our workflow within Trello for internal consistency. We then synchronize the relevant data with the client's system of choice.

Repository Management

In our development process, we consistently use git, having recently transitioned from GitHub to GitLab. To maximize its potential, we follow the git-flow approach, a system that complements our workflow seamlessly, ensuring efficient and organized version control. 

Continuous Integration

Our continuous integration process has always been centered around GitLab CI, which we use exclusively for all our projects. Its integration capabilities and efficiency make it an indispensable tool in our development workflow. 


Our workflow is key to delivering projects on schedule, consistently meeting our clients' expectations.