How We Work

Here you can get to know in advance how our cooperation will work.

Before we start explaining how Moravio works, we would like to briefly outline two software development methodologies.

Development with the help of Waterfall methodology

Software development methodology used for many decades. In general, this methodology can be identified by its classic course (usually lasting several months or longer): list of requirements by the client > analysis of requirements by the supplier > creation of the final specification > conclusion of a work contract > implementation > testing > deployment to production.

The traditional attraction of waterfall projects for clients is a fixed price and a specified delivery time. However, the larger the project, the harder it is to estimate these two factors, even with the best initial specification. The risk of additional work, changes in the project, which must be specially analyzed and priced, prolonged delivery and changes in the assignment is extremely high. As a result, this means higher costs and longer project delivery times for the client, and often also losses on the part of the supplier.

Development with the help of agile methodologies

The agile methodology generally strives to be much more flexible and to deliver maximum value in shorter sections (usually two weeks). It is built on the fact that the entire project is built iteratively and quickly adapts to changes in the client's business. The agile methodology works with the client in real time, and therefore it is necessary to determine on the client's side a person who has the right of approval and acts in the project as the main client's voice. This has several advantages for the client:

  • maximum adaptation to the client's needs,

  • continuous deployment on production and ongoing testing,

  • fewer errors,

  • greater control over the whole project and its direction,

  • faster delivery of the project to the market.

    So how do we work at Moravio?

    Current practice and experience on the czech and foreign markets have shown us that none of these methods can be applied purely. There is no waterfall without changes, modifications and additional work, nor is agile development accepted without price and time estimation. The combination with the predominance of the agile method has so far proved to be the most effective. We in Moravio work using an agile methodology called Scrum and here and there we have it slightly bent according to previous experience on the czech and foreign markets.

Analysis

Usually, at the beginning of the cooperation, we agree on an analysis with the client, thanks to which we and the client will have a better idea of ​​the scope of the project. We set a very rough time and financial estimate of the project (in the order of hundreds of percent) and if our estimates meet the client's options and expectations, we start creating a so-called backlog. In this backlog are all the so-called user stories that we created together with the client. The user story can be imagined as a short description of how a given part or function of the project should work or what is the expected output and possibly who interacts with the given part or function.

After creation of the initial backlog, we will discuss or recommend to the client the best way to start the first development cycle.

Development

The development takes place within two-week cycles, so-called sprints. In each cycle, the planning of tasks from the Backlog, the development itself, testing, documentation, deployment at the client and DEMO with the client, including the retrospective, take place. This allows the deployment of specific, pre-arranged functions or parts of a project. Gradually, we build the whole project and every two weeks the client really sees what is new, how it is used and how it fits into the project. Thanks to this, it is also possible to react flexibly to changes, because the client can visualize everything well.

Code-review

Code-review is, of course, a standard for us. This is one of the ways to constantly maintain the required quality and thus the value for the client. Code-review is the checking of the source code of one developer by another developer. If the code-review finds anything that does not meet our standards, then such code is returned for completion. Because the code review is ongoing, any reworking does not affect the time frame of the development cycle.

Testing

Modern software today cannot do without testing. We in Moravio test manually and automatically. We perform manual testing on each project and create automated smoke tests. The scope of other tests (selenium, regression, acceptance, unit, javascript, E2E, API, etc.) always depends on the agreement with the client and the nature and size of his project. Manual and mainly automated tests greatly contribute to the overall quality of the project and especially to maintaining this quality.

Project deployment

We manage all projects using the GitLab service. This allows us to version correctly, check all modifications and have a maximal overview of the project. Within GitLab, we have also created automatic deployment plans for each project to deploy any changes. We host all new projects (unless the client has another request) in the cloud. We have the most experience with Google Cloud Computing (GCP), however, we are also familiar with Amazon Web Services (AWS) or Microsoft Azure.

Testing and production environment

Each of our projects always has at least one test and one production environment created. We always deploy all modifications we make to the test environment, where we test the modifications together with the client. After approval, it is deployed for production and re-tested.

Who usually participates in your project?

The following roles are commonly involved in project:

  • client,

  • product manager,

  • project manager,

  • analysts + developers,

  • testers,

  • graphics designer,

  • marketer,

  • and other roles if needed (eg: UI / UX specialist, SEO specialist, etc.).

    Once the project is over

    In the case of development within a fixed price and scope, the end of the project is always precisely given. As the "end" of a project in agile development, we usually refer to the first version of the project agreed with the client. However, this is not the real end of the project, but only its imaginary milestone. It is often predetermined from the beginning, that it will be MVP with a certain range of functions (Minimal Viable Product). MVP is basically a phase of a project where it contains the necessary number of critical functions to run on production.

    Handover protocol (without reservations / with reservations)

    In this phase, we sign a handover protocol with the client. This protocol is either accepted and signed by the client without reservations, or the protocol contains a list of errors that must be repaired by a specific date.

    Warranty

    Each of our projects has a contractually confirmed warranty period for errors of six months from launch.

    Additional work

    Through our helpdesk application, our clients can order additional work for their projects. Each additional work is taken as a specific task and you will receive a rough time estimate as well as acceptance criteria, which must be confirmed before starting work.

    Service Level Agreement - SLA

    After project launch, we negotiate so-called SLA (Service Level Agreement) contracts with our clients. These contracts are different according to the client's requirements. We can offer you the following services:

  • guaranteed response time to tickets,

  • guaranteed developer allocation for your project,

  • project monitoring,

  • security updates,

  • technological updates.

    We always conclude SLA contracts for at least one year, they are always paid in advance and the frequency of payments can be set quarterly, semi-annually or in a single payment for the whole year.