Our Team is imple­men­ting Con­ti­nuous Inte­gra­ti­on in one of our major pro­jects. Imple­men­ting Con­ti­nuous Inte­gra­ti­on (CI) into a major and long run­ning auto­mo­ti­ve pro­ject is a lar­ge impro­ve­ment which dra­ma­ti­cal­ly rai­sed our efficiency.

When we crea­te CI not the brigh­test bulb in the box is to lea­ve pre­vious foun­da­ti­ons in ruins. It is best to get to know the pro­cess in detail from the tech­ni­cal side, con­duct sub­stan­ti­ve deba­tes with an expe­ri­en­ced per­son and, what is most necessa­ry, use the latest tech­no­lo­gi­cal solu­ti­ons. Once we have the com­ple­te pic­tu­re, we can break it down into smal­ler puz­zles. Some frag­ments are bet­ter left unch­an­ged and focus only on run­ning them. Ano­t­her good prac­ti­ce is to take advan­ta­ge of a uni­ver­sal pro­gramming lan­guage like Python and an auto­ma­ti­on tool like Jenkins which has lots of plugins to sim­pli­fy the who­le process.

When we pre­cise­ly collect all the aspects and com­bi­ne them crea­tively, we can dra­ma­ti­cal­ly incre­a­se effi­ci­en­cy without tur­ning the ent­i­re pro­ject upsi­de down. This is not the fas­test way, but the only one if we want to be sure that the solu­ti­on will meet all func­tio­n­a­li­ty standards.

Depen­ding on the needs of the pro­ject, we can cus­to­mi­ze Jenkins Pipe­line in several ways. We ana­ly­zed three ways: Jenkins jobs cas­ca­des, Blue Oce­an plugin and Decla­ra­ti­ve Pipe­line. In our case, the Decla­ra­ti­ve Pipe­line was the most sui­ta­ble. The main advan­ta­ge of which is the use of Jekin­s­file, whe­re we are dealing with Groo­vy syn­tax. Here we real­ly have unli­mi­ted pos­si­bi­li­ties of adap­ting indi­vi­du­al ele­ments, which are addi­tio­nal­ly sup­por­ted by a varie­ty of plugins.
We have some tips and tricks to help you imple­ment this solu­ti­on as well:

  • First read about com­mon Jenkins pipe­line mista­kes and draw conclusions.
  • Good repre­sen­ta­ti­on of Jenkins file have Visu­al Stu­dio Code.
  • Crea­te more sta­ges. This will show you in which step your pro­gram break.
  • Con­si­der whe­re you want to sto­rage parameters:
    • The best way is to keep the para­me­ters in one place. Jenkins or Jenkinsfile.
    • In Jenk­in­s­file, para­me­ters will be see after next che­cking out revision.
    • In Jenkins, more peop­le have an easier way to access and modi­fy parameters.
  • If we have more nodes we could defi­ned it in the para­me­ters as well.
  • If we want to call a func­tion in Python with a spe­ci­fic para­me­ter then we can use the fol­lowing solution.

  • To store addi­tio­nal pro­per­ties retur­ned out by our python code, we can use an addi­tio­nal file stored on the com­pu­ter with the Jenkins con­fi­gu­ra­ti­on. In this case, the glo­bal varia­ble props should be defi­ned at the begin­ning of the file befo­re pipe­line and defi­ned like in the pre­vious screen.
  • Post-sta­ge email con­tent should also be kept in Jenk­in­s­file. It offers HTML inter­pre­ta­ti­on and it is easier to access parameters.
  • We can repeat our build pro­cess by direct­ly modi­fy­ing the Jenk­in­s­file without modi­fy­ing it on GIT.

Pro­ject Manage­ment part

To start such imple­men­ta­ti­on, and for bet­ter under­stan­ding requi­re­ments, tog­e­ther with our Pro­ject Mana­ger, we crea­ted Requi­re­ment Tracea­bi­li­ty Matrix. We did it at the begin­ning and we deter­mi­ned all func­tio­n­al, non-func­tio­n­al, busi­ness, sta­ke­hol­der requi­re­ments. It allo­wed to deter­mi­ne the scope, needs and mile­stones which should be implemented.


Addi­tio­nal­ly we crea­ted Acti­vi­ty List, whe­re we lis­ted all acti­vi­ties, which should be per­for­med to imple­ment CI in our pro­ject. We used Git­lab as a tool, which sup­por­ted us in plan­ning, exe­cu­ting, moni­to­ring and con­trol­ling pro­cess (boards).


Moreo­ver we crea­ted Pro­ject Net­work Dia­gram, whe­re we deter­mi­ned depen­den­ci­es, did fast tracking, plan­ned acti­vi­ties, and esti­ma­ted dura­ti­ons of task and project.