Reducing the gap between operations and development using Azure DevOps


As we all know, DevOps is culture. In a company that is going to adopt its practices and principles, everyone should be “on the same side”. Continuous improvement cannot be part of our work in IT if we wouldn’t reduce the gap between development and operations. People like me, that worked in the 90s, know that dev and ops were always isolated in silos and this was “the only” way that everyone followed as a suggestion taken from the market leaders. Ticketing systems and extreme bureaucracy acted as a man-in-the-middle between those silos, transforming each organization in two people-unaware endpoints.

Speaking from a DevOps perspective, in such circumstances, a developer couldn’t know anything about how to deploy, where and how is an environment configured. On the other hand, an operation guy couldn’t get anything from a package in terms of what the application has been made for. Due to this gap we often see performance issues, underestimated hardware stuff and delayed releases. Last but not least, what about the lack of commitment and accountability of the employees working on the solution? In short, reducing such a gap is possible using a combination of DevOps culture and the right tools. We will see hereafter how my organization tries to do so using Azure DevOps.


Let’s get started with our team (DevTeam hereafter), which is working with agile methodologies, composed of ten developers and a PO. A quick note, we are using a process decision framework called Disciplined Agile ( Then, we have three operation professionals (OpsTeam hereafter). Build and deploy pipelines already exist. Builds are hosted by Azure DevOps and deploys are managed by Octopus Deploy. Getting this has been a difficult mission.

Everything is related to infrastructure in terms of servers, operative systems, virtual hosts, DNS, firewalls, security and so on, is the responsibility of our OpsTeam. As a result, they do many tasks for managing the environments. Here comes the problem. DevTeams used to create tasks in a dedicated backlog, but OpsTeam didn’t. It’s not just a matter of end-of-pipeline tasks, but also tasks for their daily basis work.

Our solution

Modify the tool, adapting its shape in order to fit in with that real scenario. A piece of cake, when you’re DevOps “inside”. How did we change Azure DevOps? Let’s describe what we did in three parts:

Team on Azure DevOps

To create a team in Azure DevOps is really a piece of cake (according to the latest releases). Just navigate to the options and select Teams:

We can add many teams clicking on New team:

We can set the team’s administrators, the permission set and an area under which every work item will be created. This area will be one of our best friends, especially when we will make our queries for gathering and analyzing the team’s related data. Additionally, also the other teams’ members could create items with this area in order to make the OpsTeam aware of them.

Team’s backlog

Now let’s navigate to Backlogs:

Good! The new backlog has been created. Going on it, we will see the team’s drop-down as well as the one for iterations. Great features!

Once created, we will see the teams’ drop-down:

Work items

Now, let’s create a new work item type. We call it Ops item. Navigate to Process customization page:

Before adding the new work item, we must ensure that the process is already a custom process, otherwise, all the edits will be blocked as shown in the following picture:

We’ve already created a SimplifiedScrum process. let’s add our item now:

Now we are going to modify the fields of the new type. Each team should be able to understand all the item’s properties. We will leave the item as is in this example. Then, we have to map the type to the backlog item list, since only the default work item types are shown initially. To do this, navigate to the Process customization page, Backlog Levels tab:

As we can see, we can also set the default item for our requirements backlog. Moreover, every Sprint backlog, based on iterations, will enable us to add the new Ops item:

Wrapping up

So, we’ve got a backlog for the IT Operations team’s members. Then, we’ve related it to their Azure DevOps team. Additionally, we’ve got a particular work item type (not mandatory, but really useful for querying it or adding it into dashboards) target of IT Operations’ job and a dedicated Area Path. We can make many relationships between items of both our backlogs. Here is an example of how an activity can be managed and organized (extension: Work Item Visualize):

As you can see, the Ops items are Successor of the “development” Product backlog items. Indeed, the Ops Items will be finished after the PBI, typically. Think about creating s DNS or a network path to let the production app work in production.


With this solution, we’re decoupling backlogs. Moreover, we’re isolating the management maintaining the relationships between work items that reside on different boards. At the same time, we’re making a strong synergy between Development and Operations.Then, in a couple of clicks, we can switch teams and backlogs, using Azure DevOps Boards. We can track changes in both the departments, also for audit requirements. In my opinion, this helps the enterprise awareness and facilitates the continuous improvement of all the teams and any member’s skill.

DevOps journeys series – Vertica release pipeline with Azure DevOps – Ep. 01 – development (part 2)


In the previous post we’ve described the idea behind the automation we’re trying to implement on a scenario based on MicroFocus Vertica database.

How it works

This “sandbox” is not a real isolated development workstation. Let’s separate it into two parts, the first one for the development on everything but Vertica (Windows local workstation) and the other one for a Vertica instance (probably Unix/Linux VM) shared between developers.

In this shared instance we will get a schema for each developer is working on the solution, in order to let everyone to get his own “environment”.

The source control folder tree (which will be TFVC source control on-premises) will be designed on the desired branch as the following:

            /Tables ...
            /Views ...

As you ca see, under the Project folder there is the Vertica database folder, which contains, schema by schema, all the .sql files for Tables and Views DDLs (CREATE TABLE and CREATE VIEW). You can notice also .ps1 files, which contains the list of executions based on a certain order (business driven).

The file for a, let’s say, “Table1”, can be like this one:

    RowId int NOT NULL,
    RowStringValue varchar(30) NULL,
    CONSTRAINT PK_<schema>Table1 PRIMARY KEY (RowId)

We’ve added a :SCHEMA parameter, which allows each developer to create its own schema as described before. This is the only way we’ve found for isolating developers in a Vertica shared instance, avoiding an instance for each developer, which could be resource intensive for available PCs. Running the application locally, before committing any change set to the Source Control, a simple tool will execute .sql files with the new schema name and in the sort order given by the .ps1 file.

The Tables.ps1 file can be as the following:


$schemaCommand = "vsql -h $hostname -p $port -U $user -w $psw -v SCHEMA=$schemaName -f $(Join-Path $scriptsFolder "Table1.sql")"
Invoke-Expression -command '$schemaCommand'

$schemaCommand = "vsql -h $hostname -p $port -U $user -w $psw -v SCHEMA=$schemaName -f $(Join-Path $scriptsFolder "Table2.sql")"
Invoke-Expression -command '$schemaCommand'

You may notice the term “vsql”, which is the command line provided by Vertica for executing queries. Further information here.

Also, usernames and passwords will be stored in an external config file (or a secured API), like the following one:

"host": "MyHost.Hos.Ext",
"port": 1234,
"user": "user",
"psw": "password",
"schemaName": "MYSCHEMA"

We’ve got the DDLs, the PoSh files for executing them and the Vertica command line. Good, in a development environment, however, a set of tools should be prepared for helping us to keep these artifacts on a single pipeline, too. This is the reason why we’ve created a “builder” script, like  this one:

$config = Get-Content (Join-Path $currentFolder "Build-Config.json") | Out-String | ConvertFrom-Json

$schemaCommand = $(Join-Path $scriptsFolder "Tables.ps1") 
$schemaCommand += " -hostname $($" 
$schemaCommand += " -user $($config.user)"
$schemaCommand += " -port $($config.port)"
$schemaCommand += " -psw '$($config.psw)'"
$schemaCommand += " -schemaName $($config.schemaName)"
$schemaCommand += " -scriptsFolder $scriptsFolder"

Invoke-Expression -command $schemaCommand

This is another layer of management, which allows us to organize every part of the DDLs to be executed against Vertica.

Note: Our scripts will destroy and rebuild any given SCHEMA. But this is the way we like.

Now, let’s see the possible scenarios.

Start from scratch or get started

When someone wants to start from scratch, this is the pipeline to follow:

  1. get latest version of the branch;
  2. check and change the configuration file (JSON);
  3. execute the create-vertica-database-from-scratch.bat file (it contains our powershell “build” script);
  4. that’s it, we’ve got a new schema in Vertica, empty and ready to be consumed.

If you want to preserve your data, this is not the right path for you. Executing the “builder” tool is optional.

New development

When a developer would make and try its changeset:

  1. change Visual Studio application (SSIS or SSRS here) when needed;
  2. change the Vertica schema (adding tables, columns and so on);
  3. get the .sql file of a new object or change the .sql file of an object which has been updated;
  4. replace them into the TFVC file structure;
  5. change the .ps1/.txt files if any DDL has been added (or if something that impacts on the order occurs);
  6. build the Visual Studio application and try it;
  7. When everything works good, check-in.

Now, everyone can get the latest changes in a CI way.

Get delta changes

When a developer is going to get the latest changes that contains an updated version of the Vertica objects, but wants to preserve its data, this is a little bit more tricky. The person who has made the change could share in a collaborative chat tool the ALTER script. This is not so reliable and comfortable, but without any comparison tool, there isn’t any best way to make this happen.

That being said, we’ve implemented our diff-script generator, based on the analysis of Vertica metadata (the catalog, browsing v_internal objects). So, after our friend gets the latest version, he executes a generate-diff-script.bat tool and lets this script to execute the generated ALTER script. Tricky, but it works like a charm (we will speak about this comparison tool in next posts, maybe) . Anyway, we’re looking forward hearing updates from MicroFocus. Hopefully, we’ll get an official diff tool from them soon!


I’ve just shown the way we’re managing tables DDLs and how we’ve created PowerShell scripts, but the real scenario is more complex. We have to drop Vertica schema (CASCADE DROP) before, then re-creating the new parametrized schema, then tables, then views and so on. Sometimes, we’ve got Vertica schemas which are referenced each other, so we have to create for everyone of them tables before, then views. The business logic is managed by how we write the “build” PowerShell script as well as the automated build process will.

Also the build process is not always “straight”. Some of the business processes need to be managed in a dedicated way. Cross reference will occur but this is the job that the “builder” will do. Both for the manual and the automated one. Moving responsibility to the build process allows us to feel more comfortable about our development solution.

Last, but not least, the manual-development-build process allows the developer to choose between re-create the database or not. They should not waste time in managing the things that a script can do repeatedly and efficiently. This is the reason why we kept somehow static the PowerShell instead of writing complicated business logic. Just adding rows of vsql invocation in the right order, that’s it.

Agile @ School – Anno Terzo – Presentazione dei Progetti e Conclusioni

Anche quest’anno Agile@School è giunto al termine. Il percorso è stato come sempre ricco di nuove esperienze, imprevisti e soddisfazioni; un modo per osservare come le classi di studenti siano in grado di applicare gli insegnamenti portando a termine progetti fatti, finiti e funzionanti.

Sarà proprio questo il tema centrale del post: la presentazione dei progetti. Non ci soffermeremo sui singoli team perchè ognuno di essi, con i propri pregi e difetti, è stato in grado di mostrarci quanto di meglio potesse creare e di esporlo a tutta la classe.

Presentazione dei progetti

Ciascun team è stato chiamato ad esporre sotto forma di *pitch* il proprio lavoro, immaginando di avere di fronte i propri investitori (Gabriele, i professori e il sottoscritto) da convincere, sia dal punto di vista del valore tecnico che da quello commerciale. In 20 minuti, tutti hanno avuto il compito di mostrare le funzionalità del prodotto in termini hardware e software, con l’aggiunta di un possibile piano di vendita a sostenere il tutto. Grazie a quest’ultimo punto, anche i team non tecnicamente eccelsi avrebbero potuto “tenere il passo” puntando di più sul lato vendita e di design.

Per rafforzare quanto detto poco fa, il codice non è nemmeno stato preso in considerazione al momento della presentazione: Gabriele, tuttavia, se n’è occupato in prima persona confrontandosi faccia a faccia con i ragazzi consigliando loro eventuali migliorie, solo per determinare i punti deboli lato sicurezza, ottimizzazione e qualità dei listati.

Per ogni squadra, abbiamo deciso di valutare con il seguente questionario:



Giudizi, non voti. Focalizzazione su attitudini, non su skill. Tutto quanto di ottimistico (o critico costruttivo) che possa aiutare i docenti nella valutazione finale.

Guardate qui alcuni estratti di quanto visto durante la giornata:


Conclusioni di fine percorso

Vi è da dire che più l’edizione di Agile@School si ripropone e più diventa evidente l’importanza di focalizzarsi sugli aspetti della gestione del team. Ricordo ancora il primo anno, quando tutto era in fase embrionale, momento in cui ci siamo prestati ad aiutare i ragazzi sul codice vero e proprio, dimenticando il motivo per cui questo progetto è nato: fornire ai ragazzi gli strumenti e le attitudini per affrontare un qualsiasi progetto, personale o di team, che può prendere vita in un contesto lavorativo come nella sfera privata (time management).

Ecco, fare una retrospettiva su questo, sempre in puro stile agile, ci rende orgogliosi dei passi fatti fino ad oggi e di quanto ne potremmo ancora fare, affinando tecniche ed organizzazione al fine di lasciare ai ragazzi un’impronta il quanto più possibile ispiratrice per il loro futuro.

Per quest’anno è tutto, grazie per averci letto fino a questo punto.

E stay tuned! 🙂

Agile@School – Anno terzo – Apertura del progetto

Siamo già al terzo anno consecutivo. Il tempo vola, ma devo dire che i progetti che sono nati in Engage IT Services sono anche solidi, graditi e duraturi. È successo con gli eventi (quest’anno ben tre per coprire i trend topic IoT, DevOps e il nostro SQL Saturday) e accade anche con Agile@School. Pensate che nel 2017 abbiamo “aperto” anche una nuova realtà in quel di Rovigo, grazie a Michele Ferracin (qui i suoi post in reblog e le statistiche finali). Insomma, il motore gira, forte e non dà cenni di arresto. Quindi siamo qui, 2018 nuovo vestito per il progetto e la scelta di scrivere i post ad esso relativi in italiano, anche per rispettare quanto fatto nel nostro Paese.

La nostra azienda è finalmente entrata a far parte di un progetto più ampio di Alternanza Scuola Lavoro per la nostra scuola di riferimento (I.I.S.S. Gadda di Fornovo, Parma) per cui, a differenza delle edizioni precedenti, quest’anno potremo sfruttare un intero mese. Gli studenti non avranno più incontri isolati ma una serie di giornate consecutive di lavoro “sul pezzo”, senza dispersioni e senza includere ore extra scolastiche, sulle quali è piuttosto difficile investire per gli adolescenti. Ma non solo, quest’anno abbiamo anche un “corpo docenti”: non mancherà chi ci ha supportato fin dall’inizio (la prof. Pinella Pedullà, informatica e tecnologia) ma avremo anche importanti aggiunte, come il prof. Stefano Saccani (informatica), la prof. Enrica Groppi, il prof. Graziano Maniello e tutti quanti hanno supportato il progetto “donando” le ore del normale programma di studi.

Edizione 2018

Partiamo con la descrizione di Agile@School 2018. Due anni fa, l’edizione pilota, spiegammo ad una decina di ragazzi di quinta superiore come affrontare un singolo progetto in agile (Scrum), mentre l’anno scorso abbiamo optato per un’idea multi-progetto e multi-team con supporto di kanban board. In entrambi i casi, la base è stata Visual Studio Team Services utilizzato con template differenti.


Quest’anno Gabriele Etta (lo ringrazio per essermi sempre di aiuto) ed io abbiamo optato per lasciare libertà agli studenti, concentrando l’iter sulla self-organziation e sul principio di responsabilità. L’obbiettivo è in definitiva quello di raggiungere un approccio “dal basso verso l’alto” (bottom-up) in cui scelte e proattività vincono su comando e controllo. Come? Ponendo gli studenti di fronte ai problemi, lasciandoli fare, sempre nell’ottica della realizzazione di un prodotto/servizio. Ovviamente la nostra presenza è quella che consente loro di ottenere consigli pragmatici su comportamenti e strumenti disponibili.


Le novità

Questa edizione porta con sé differenze anche per la classe ed il numero di persone. Una ventina di ragazzi di terza, che molto probabilmente incontreremo ancora nel 2019 e, perché no, anche nel 2020. Ed è questa la vera novità. Agile@School sarà un progetto a lungo termine, non dedicato ad un solo anno scolastico. Approfondiremo la conoscenza con gli studenti e potremo valutarli anche su più aspetti, nel tempo. A mio modo di vedere ciò corrisponde ad un grande valore aggiunto per gli studenti, per la scuola e per noi. Un percorso da seguire tutti insieme.

Il primo incontro

Nella prima “puntata” abbiamo affrontato un punto delicato della comunicazione. Il farsi conoscere, capire le proprie attitudini ed esporre i propri interessi. Ma non solo, uno dei primi passi per responsabilizzare i ragazzi è stato quello di selezionarsi a vicenda, di lasciar costruire i team naturalmente, senza imporre nulla. Certo, abbiamo cercato di far capire che un team può essere costituito da ruoli diversi e che non è una cattiva idea far crescere anche persone che non sono “forti” in particolari ambiti, ma quello è stata l’unico consiglio. Abbiamo in poco tempo ottenuto cinque team, due dei quali da cinque elementi e tre da quattro.

I progetti

I professori prima dell’incontro hanno creato un elenco di cinque idee, tutte orientate al mondo dell’IoT e, per essere più precisi, al rapporto tra l’informatica e l’elettronica ai giorni nostri. Tutti i progetti sono basati su Arduino e sul kit di sviluppo con esso fornito. Ogni idea è vista come una “partenza”, che corrisponde al requisito minimo e necessario ma che, allo stesso tempo, può essere estesa e resa “personalizzata” a scelta del team, con analisi, implementazioni, studi e rischi annessi. Nel prossimo post descriveremo meglio i contenuti, ma possiamo affermare che la base è tendenzialmente la gestione di sensori di vario genere e la presentazione su web con utilizzo di storage per il salvataggio degli eventi che si verificano. Il prof. Saccani, dopo la presentazione dei progetti, ha osservato con noi i ragazzi procedere alla creazione autonoma dei team e all’assegnazione di progetti. Dopo un primo conflitto di preferenza (ogni idea poteva essere assegnata ad un solo team) e dopo aver capito la possibilità infinita di estensioni applicabili in ogni ambito, le squadre hanno concordato le assegnazioni finali.


Le cerimonie

Il primo meeting che è stato suggerito ai ragazzi è il daily meeting. Con un’occasione del genere (tutti i giorni a lavoro per un mese, ricordo) non potevamo fare altrimenti. Abbiamo spiegato le tre fatidiche domande, illustrando i modelli di risposta accettabile e non, ponendo l’attenzione sui tempi e sul livello di dettaglio. Fare il daily meeting è stato uno dei compiti assegnati a tutti.

La gestione delle attività

Come strumento per il task management abbiamo suggerito Trello e come chat collaborativa Slack, cercando di non consigliare altro. Come compito, alla fine della settimana, ogni team dovrà aver ideato un nome per il proprio “prodotto”, un’analisi iniziale, soprattutto funzionale, e una relazione per descrivere i casi d’uso. E chiaramente dovrà presentarlo, simulando una sorta di “ricerca fondi” da investire nella produzione concreta del prodotto stesso. Proprio come una piccola startup.

Per chiudere

Tutti ci aspettiamo soddisfazioni da Agile@School 2018 e confidiamo nel fatto che sia una buona base per i prossimi anni. Le premesse sono più che soddisfacenti, ma dovremo valutare passo dopo passo, cercando di adattarci al cambiamento. Al prossimo appuntamento…

Stay tuned! 🙂

Agile@School 2017 – This is the end

All the good things come to an end, right? And this is true also for Agile@School 2017. However, no worries, although I’m becoming a dad, I’m pretty sure I’ll keep making the students more aware of the Agile principles and practices.

There are only good news, to be honest. The first one is that Michele Ferracin, a friend of mine at community, is starting to keep in touch with schools (we really don’t know how many of them will participate) in order to start Agile@School also in Padova. “Bring the project in two cities”, perk reached! The second news is about the students this year. Everything is set up and running. Everyone is ready. Each team has chosen how to present the results to the exam’s board:

Software and Tech

The Messinesi team (Amanda and Alex) has prepared a Prezi presentation, whose goal is to depict the tools they’ve involved. They explain also the technologies and the usability of the collaborative chat they’ve created. Additionally, the board can try the “product” interacting with laptops and mobile phones.


AI and Bots

The Random team (Thomas and Luca) and the Scrubs team (Enea and Sebastiano) have created a 3 min pitch video with:

  • an introduction of their chat bots (via Prezi and Power point)
  • simple explanation of the tech behind them
  • a couple of self interview (twice per bot) in order to add something fun


The Domotic team (Nicodemo and Mattia) and the Bar Santa team (Simone And Mirko) will show how the projects work, since they’re totally based on hardware. Smart Home vs Hacked Remote Controlled car. We’ve got already some spot:

Cognitive Services

The Human Recognizers team (Marco and Francesco) will present a website in which the exam’s board can play with cognitive services. They demonstrate how the webcam can recognize faces, mood and so on, using a mobile application.

This is the Prezi presentation.

As you can see, they’ve worked very well. The project are amazing and we’ve awarded everyone with the diploma, as usual:


This year we’ve reached great results and we’re proud of all the work done together. We’ve asked also to fill in a survey and the feedback are the following:

And now, good luck guys! see you next year, hopefully!

Stay tuned

Agile@School 2017 – When the projects come true

Last time we had a great time. I’d have expected some trouble, some problem to manage. Well, everything has been well done. Anything goes. This is the reason why I’m attaching the pictures of the results hereafter, because it’s the best way to describe how the students were making their ideas. Keep in mind that we’re speaking about 18 years old guys, not startups!

Pictures paint a thousand words.

Introducing the teams:

The Messinesi team (Amanda and Alex) is developing a real time collaborative chat. Similar to the famous Slack, its purpose is to make the team’s member more aware of technologies used nowadays, like SignalR and the latest releases of the .Net framework. The name of the project is Notify. The guys are also following an interesting course with Visual Studio, in order to be prepared to become real developers in the future. As you see below, the development is still in progress, it’s just a matter of design. Due to the nature of the project itself, we need to wait for the next releases.

The Random team (Thomas and Luca) is presenting us a natural language bot, without any deep learning in this first release, which replies to a set of questions about Italian famous writers. It replies showing links, information and texts about the author requested by a real user. The name of the project is Italian Authors and it’s been made by integrating the APIs. It will eventually run on Facebook Messenger via Heroku platform. Lots of technologies!

The Scrubs team (Enea and Sebastiano) is working on a similar project, based on a natural language bot, without any deep learning in this first release, which replies to a set of questions about two topics which we should take care of, sports and photography. Also in this scenario, the real user interacts with the chatbot. The name of the project is CPP and it’s been made by integrating the APIs. It will eventually run on Facebook Messenger via Heroku.


The Domotic team (Nicodemo and Mattia), as the name of the team describes, is realising an IoT real time application which interacts with a prototype of a “smart house”. You can open and close doors and windows, turn on and off the lights. In this first release, you cannot clean the floor, but I guess we need more time for that feature… Actually the guys could integrate a robot 🙂 . The name of the project is Future House and it’s developed for Arduino using also php.


The Human Recognizers team (Marco and Francesco) is developing a face recognition Android app, which associate pictures of people in order to get information about age, mood and so on, also printing a string related to the mood itself. The name of the project is iFinder in consumes Android sdk and Face API by Microsoft. The result is impressive.

The Bar Santa team (Simone And Mirko) is hacking a remote-controlled car. As a result, they’ve got a super car with a camera onboard, stepped motors for wheels, and sensors. Everything mixed in a dedicated chassis, printed by the school’s 3D printer. The name of the project is SuperCar (do you remember Kit?) and it’s been made for Raspberry Pi3.


I don’t want to bother you with the teams’ retrospectives and ceremonies, but this time they worked perfectly. Each team started to discuss with us about the pros and cons of their choices, the things to do and the ones to avoid in the future. They depicted everything using starfish diagrams (in italian):


What can I say? AWESOME! This is how I’m feeling right now. Lots of ideas, technologies, integrations, and definitely FUN! I hope that everyone else agrees with me.

I guess that the exam will be a great show for those guys, also. The next post will be about the pitch videos they’ll create for each project. I’m excited but I have to bite my tongue, because I’ve already seen something and I don’t want to spoil anything, so…

Stay Tuned!