Linnovate CALM (Cloud Application Life-cycle management)


Israel Office



Europe office


Linnovate CALM (Cloud Application Life-cycle management)
submitted by: admin
In Linnovate’s years of operation, we find that some of the best value that we can deliver clients we work with is the ability to import our development methodologies and jumpstarting the clients’ dev-ops and ALM (Application Lifecycle Management) practices.
Linnovate CALM (CALM) is a set of predefined processes that start in the development and go through different phases of testing, deployment, maintenance, business insights and SLA spanning across an entire lifecycle of a software product.
Throughout the CALM process, each of these steps is monitored and controlled, followed by proper tracking and documentation of any changes to the application.


The first step is to interview the client and learn about his applications needs, bottlenecks and current architecture, we discuss the current release strategy and the associated pain points in the client's current process.



Source Control

The code is managed by git in Github, Bitbucket, local or remote Gitlab.
Guidance is provided in the proper use of the SCM’s various features such as branching, tagging, releases, code review, wiki-based knowledge management and more.




Gitflow is instructed and integrated with the CI process that is bound to the dev, stage and production branches.
Gitflow provides a proven strategy of how to approach the various stages needed.


Jenkins is used with the relevant plugins to be aware of interactions with the tracked branches in the Git repository
Jenkins provides the central hub which is in charge of running the “build” which might run tests, deploy the code upon success and notify the team through the notification service used.




Notification Service

Rocketchat/Slack/Hipchat/Teams is used to provide a central location for all of the client's notification and form of radically improving project transparency and communication.




Modern applications tend to transform from larger monoliths to microservices architecture - creating slim stateless microservices devoted to one single task and thus enabling the client to scale the specific area in the application which has a bottleneck. This leads to radical costs saving derived from much better use of the available infrastructure. The latest trends regarding hosting microservices lead to the use of Dockers.

Based on the architecture that was specified and discussed we segment the application to smaller parts and host them within scalable Dockers.







1.      Architecture review

2.      SCM (github/bitbucket)

3.      Gitflow

4.      Jira integration

5.      Notifications basic (bitbucket, jira)

6.      Basic Training


1.      Push to branch invokes “build

2.      Jenkins test invocation

3.      Notifications integration

4.      Basic Training


5.      Jenkins (basic)

6.      Dev environment auto deployed from dev push

7.      Docker based implementation

8.      Rancher based docker orchestration


1.      Centralized logging using ELK stack

2.      Docker monitoring using Prometheus/Grafana

3.      Notifications integration

4.      Backups

5.      Basic Training

Business Insight

1.      Implement custom dashboard to provide insights regarding the business KPIS


Support and maintenance for your application




Add new comment


Welcome popup block