Director OutSystems

Remco Dekkinga 2.jpg

Remco Dekkinga.jpg

large_headerimg-01.png

medium_headerimg-01.png

small_headerimg-01.png

thumbnail_headerimg-01.png

headerimg-01.png

# The Age of Digital Transformation and Remote Communications Has Arrived

The leaders of modern application development and cloud communications are inviting you to join the **2020 OutSystems-Vonage-LINKIT Developer Challenge.**  
A growing number of developers like you use *OutSystems* to build applications and workflows faster and accelerate digital transformation around the world. With *Vonage APIs*, you can now embed messaging, voice and video calls in your workflows. *LINKIT* has built components available on the OutSystems Forge to make it super easy to blend the power of OutSystems and the flexibility of Vonage communications.
The applications are limitless and we want to give the community a chance to push the boundaries.

We can’t wait to see what you build!

## What you need to know
## **1. Developer Challenge: November 4 - November 13, 2020**
- Projects are submitted individually, but teams are welcome, too (register one person per team).
- You have 2 weeks to build your application or workflow using the OutSystems platform and the [Vonage components](https://www.outsystems.com/forge/list?q=&t=&o=most-popular&tr=False&oss=False&c=&a=&v=&hd=False&tn=vonage&scat=forge) built by LINKIT.
- We’ll send you the information on how to submit your project.
- You will have the option to submit your project on the Forge no earlier than November 10.

## **2. The Prizes!**
<u>**Grand Prize**</u>  
**Apple Watch Series 6 provided by Vonage**  
**Plus a $350 Amazon gift voucher from LINKIT**   
**Plus a 100% Exam Voucher + SWAG Kit from OutSystems**  

<u>**6 Category Prizes:**</u>  
- Best social value   
- Best UX   
- Best in Europe, the Middle East and Africa   
- Best in the Asia-Pacific Region   
- Best in the Americas.  
- Best Student project.    

Each category prize winner will receive:
- a one-year subscription to www.medium.com provided by LINKIT
- a 50% discount Exam Voucher + SWAG Kit from OutSystems

Additionally, the first 50 projects submitted will receive:
- Vonage socks
- OutSystems T-Shirt. 

Even if your project doesn’t win a prize, it may be showcased by the organizers and, of course, referenced in your portfolio. 
[Terms and conditions](https://s3.eu-west-1.amazonaws.com/nl.linkit.production.user-data/2020_Dev_Challenge_starter_kit_terms_and_conditions_3cec8dc9e3.pdf) for this challenge apply.


## **3. Kick-Off Webinar: November 4, 2020**
- Asia Pacific session: Nov 4: 8 pm Pacific Time /11 pm Eastern Time (Nov 5: 9:30 am Bangalore/12 pm Singapore and Hong Kong/3 pm Sydney)  
- Americas/Europe session: Nov 4: 10am Pacific Time / 1pm Eastern Time / 18:00 Portugal/UK / 19:00 CET

The webinar will include practical use cases on how to use the Vonage components* on the OutSystems Forge and valuable ideas for your project.
Speakers will include:
- Rui Barbosa, Hackathon Guru at OutSystems
- Rick Pfleger, Vonage API Architect
- Parma Bhagwandin, Vonage Component and OutSystems Wizard at LINKIT  

After you register for the Developer Challenge, you will receive an email with more details and instructions how to join the challenge.
The live webinar will include Q&A.
The event will be recorded for on-demand viewing.

**developed and supported by LINKIT*

> **Sign up now using the register button on this page**

Low-code is a way of software development that focuses on visual programming with predefined components. Building blocks that have already proven themselves, and that adapt perfectly to business logic. The big advantage is that with less programming and less need for specialist knowledge, applications can be built at a rapid pace. Apps that can be used in both SME and enterprise environments. Web and mobile apps can be set up in no time and a prototype is ready within a day. LINKIT specializes in the Low-code platforms that according to Forrester and Gartner are the most promising: OutSystems and Mendix.

Low-code is een manier van software-ontwikkeling die gericht is op visueel programmeren met vooraf gedefinieerde componenten. Bouwblokken die zich reeds bewezen hebben, en zich perfect schikken naar business-logica. Het grote voordeel is dat er met minder programmeerwerk en minder specialistische kennis in een hoog tempo applicaties kunnen worden gebouwd die bruikbaar zijn in mkb- en enterprise-omgevingen. Web- en mobiele apps zijn binnen no-time op te zetten en een prototype staat binnen een dag. LINKIT is gespecialiseerd in de Low-code platformen die volgens Forrester en Gartner het meest veelbelovend zijn: OutSystems en Mendix.

Director New Business

Omid Darroudi 4.jpg

Omid Darroudi.jpg

With Low-code you can create a prototype for an enterprise-level application within a day

Met Low-code maak je een prototype voor een enterprise-level applicatie binnen een dag

Visual programming with proven components

Visueel programmeren met bewezen componenten

With an application for ModuleMakers, a corporate start-up that emerged from tech giant Croonwolter&dros, LINKIT captured a complex engineering and calculation process in one handy program.

There is a lot to consider when developing a new building or making an existing building more sustainable. For example, it is necessary to consider which systems for climate management should be installed and which materials are required. With millions of combinations of options and various variants from pipes and insulation material to mounting brackets and taps, this is quite a complicated, error-prone and time-consuming job for ModuleMakers. Because everything at ModuleMakers revolves around making the work more modular and less error-prone, they turned to LINKIT to transform this design process. First, the excel file, which requires manual input, was converted into a program. LINKIT and ModuleMakers developed the solution in a joint team: a decision tree that streamlines the entire design process to identify which modules fit which type of buildings, and the right combinations can be easily put together.

**Energy from many angles**  
For ModuleMakers, it was not the first time they collaborated with LINKIT. Earlier, an application was already developed with which product engineers could design building systems. The new issue was complex: the products already developed had to be fully configurable with a new application, including various conditional conditions. For example, you can think of the height of a building, the combination of insulation material with pipes of a specific diameter or, more generally, whether different connections fit together. Therefore, the project started with a design sprint, in which the energy was immediately good. "We sat down with everyone involved, which allowed us to paint a complete picture of the challenge," says Arvid Duijzer, founder of ModuleMakers. "As a result, the result fits in well with the wishes, and the project quickly gets a high level of involvement."

**To the essence…**  
Therefore, during the design sprint, it was important to go back to the core of the issue: How can we optimize the engineering process to make both faster and better modular configurations? The mixed team, including developers from both LINKIT and ModuleMakers, eventually got through to the essence. Jonathan Wigmans, UX designer at LINKIT: "Once we established that those modular products actually worked with standard objects and variables, we had the building blocks we needed for the solution. This allowed us to put together every possible product configuration."

**…and the drawing board**  
At the end of the design sprint, a prototype was immediately made to see whether the solution was in the right direction because the new application had to be robust, error-free, accessible, and easy to maintain. "In the technology world, people think visually," Arvid explains. "By directly involving the users in the process, we were able to increase support." Jonathan agrees: "It shows the power of design to solve these kinds of process problems."

**Low code for a fast turnaround time**  
The application was developed in low code (a technique that works with pre-made functionalities so that little development time is required, ed.) with OutSystems. During the design sprint, the developers immediately validated the technical feasibility of the ideas, which ensured that the development got off to a flying start. Then, the solution was built in five two-week sprints based on the visual and technical design. This resulted in a prototype, to which a few parts still had to be added, including the structure for the database and the output that was needed for other departments within ModuleMakers.

This application is certainly not a one-to-one translation of the original Excel. Jonathan explains: "With what we have delivered, we have gone for the greatest possible added value. It has not become a questionnaire, but an extensive decision tree, with conditional logic and an underlying database that can be continuously supplemented. This also makes it future-proof." The team eventually developed the application in an astonishingly short period of time. ModuleMakers received an entirely usable technical application after only ten weeks, of which only the database had to be filled. The choice for low code also meant they could easily manage their application themselves and, if necessary, quickly adapt it without being dependent on LINKIT.

**Savings from start to finish**  
The ModuleMakers product configurator is used by the calculation and engineering departments within the engineering process. They can put together the various parts on a canvas, after which the output and the resulting options can be used to make a suitable design. The time that ModuleMakers saves with this is enormous. Arvid: "With this application, we now do twenty times as many calculations in the same amount of time, plus: the margin of error is rolling down!" Jonathan adds: "The fact that this information is now embedded in an application makes you as an organization much more resilient to changes in, for example, your workforce, but also more agile in the products you make and deliver." With the addition of the application, ModuleMakers strengthens its foundation to help customers build more efficiently, cleaner and safer with modular products. In the future, there are certainly options for further integration of this application in other processes, such as in the production of construction drawings. Arvid: "The impact of this innovation is that we can automate on a large scale, not just in one piece, but in the entire process from customer to delivery."


Met een applicatie voor ModuleMakers, een corporate start-up die voortgekomen is uit tech-gigant Croonwolter&dros, ving LINKIT een complex engineerings- en calculatieproces in één handig programma.

Bij de ontwikkeling van een nieuw gebouw of verduurzaming van een bestaand gebouw komt veel kijken. Zo moet bijvoorbeeld bedacht worden welke systemen voor klimaatbeheer moeten worden aangelegd en welk materiaal daarvoor nodig is. Met miljoenen combinaties van mogelijkheden en diverse varianten van leidingen en isolatiemateriaal tot bevestigingsbeugels en kraantjes is dat een behoorlijk ingewikkelde, foutgevoelige én tijdrovende klus voor ModuleMakers. Omdat alles bij ModuleMakers draait om het modulairder en minder foutgevoelig maken van het werk, klopten ze bij LINKIT aan voor de transformatie van dit ontwerpproces. De excelfile, waarbij handmatige invoer nodig is, werd omgezet in een programma. In een gezamenlijk team ontwikkelden LINKIT en ModuleMakers de oplossing: een beslisboom die het hele ontwerpproces stroomlijnt, zodat precies duidelijk is welke modules passen bij welke type gebouwen en de juiste combinaties makkelijk kunnen worden samengesteld.

**Energie uit vele invalshoeken**  
Voor ModuleMakers was het niet de eerste keer dat zij samenwerkten met LINKIT. Eerder werd namelijk al een applicatie ontwikkeld waarmee product engineers gebouwsystemen konden ontwerpen. Het nieuwe vraagstuk bleek complex: de reeds ontwikkelde producten moesten met een nieuwe applicatie volledig te configureren zijn, inclusief diverse conditionele voorwaarden. Daarbij kun je denken aan de hoogte van een gebouw, de combinatie van isolatiemateriaal met buizen van een bepaalde diameter of meer algemeen of verschillende aansluitingen wel bij elkaar passen. Het project startte dan ook met een designsprint, waarbij de energie er meteen goed in zat. “We hebben met alle betrokkenen samen gezeten, waardoor er een volledig beeld van de uitdaging kon worden geschetst,“ vertelt Arvid Duijzer, oprichter van ModuleMakers. “Het resultaat sluit hierdoor goed aan bij de wensen en het project krijgt snel een hoge betrokkenheid.” 

**Naar de essentie…**  
Tijdens de designsprint was het dus zaak om terug te gaan naar de kern van het vraagstuk: Hoe kunnen we het engineeringsproces optimaliseren, om zowel snellere als betere modulaire configuraties te maken? Het gemengde team, met daarin onder andere ontwikkelaars van zowel LINKIT als ModuleMakers, drong uiteindelijk door tot de essentie. Jonathan Wigmans, UX-designer bij LINKIT: “Toen we eenmaal vast hadden gesteld dat die modulaire producten eigenlijk werkten met standaardobjecten en variabelen daarop, hadden we de bouwstenen die we nodig hadden voor de oplossing. Daarmee konden we iedere mogelijke productconfiguratie samenstellen” 

**…en de tekentafel**  
Dat betekende dat er, aan het einde van de designsprint, ook meteen een prototype gemaakt werd om te kijken of de oplossing in de juiste richting zat. Want niet alleen moest de nieuwe applicatie robuust en foutloos zijn, hij moest ook laagdrempelig én makkelijk te onderhouden zijn. “In de techniekwereld denken mensen beeldend,” legt Arvid uit. “Door direct de gebruikers mee te nemen in het proces, konden we het draagvlak vergroten.” Jonathan beaamt dat: “Het laat zien wat de kracht van design is om dit soort procesmatige problemen op te kunnen lossen.”

**Low code voor een snelle doorlooptijd**  
De applicatie werd uitgewerkt in low code (een techniek die werkt met vooraf gemaakte functionaliteiten, waardoor weinig ontwikkeltijd nodig is, red.) met OutSystems. Tijdens de designsprint hebben de ontwikkelaars direct de technische haalbaarheid van de ideeën gevalideerd, wat ervoor zorgde dat de ontwikkeling een vliegende start kende. De oplossing kon worden gebouwd in vijf sprints van twee weken, aan de hand van het visuele en technische ontwerp. Hiermee stond er een prototype, waaraan nog wel enkele onderdelen moesten worden toegevoegd, waaronder de structuur voor de database en de output die nodig was voor andere afdelingen binnen ModuleMakers.

Deze applicatie is dan ook zeker geen een-op-een vertaling van de oorspronkelijke Excel. Jonathan licht toe: “Met wat we hebben opgeleverd, zijn we echt gegaan voor een zo groot mogelijke meerwaarde. Het is geen vragenlijst geworden, maar een uitgebreide beslisboom, met voorwaardelijke logica en een achterliggende database die continu aangevuld kan worden. Daarmee is het dus ook toekomstbestendig.” Het team ontwikkelde de applicatie uiteindelijk in een verbazingwekkend korte periode. ModuleMakers kreeg na slechts tien weken een volledig bruikbare technische applicatie in handen, waarvan enkel de database nog gevuld moest worden. De keuze voor low code betekende voor hen tevens dat zij hun applicatie zelf makkelijk kunnen beheren en, indien nodig, snel aan kunnen passen zonder daarbij afhankelijk te zijn van LINKIT.

**Een besparing van begin tot eind**  
De ModuleMakers-productconfigurator wordt gebruikt door de calculatie- en engineeringafdeling binnen het engineeringstraject. Zij kunnen op een canvas de diverse onderdelen samenstellen, waarna de output en daaruit voortvloeiende opties kunnen worden gebruikt voor het maken van een passend ontwerp. De tijd die ModuleMakers hiermee bespaart is enorm. Arvid: “Met deze applicatie doen we nu twintig keer zoveel calculaties in dezelfde tijd, plus: de foutmarge rolt naar beneden!” Jonathan vult aan: “Dat deze informatie nu verankerd ligt in een applicatie, maakt dat je als organisatie veel weerbaarder bent voor veranderingen in bijvoorbeeld je personeelsbestand, maar ook wendbaarder in de producten die je maakt en levert.” Met de toevoeging van de applicatie versterkt ModuleMakers haar fundament om met modulaire producten klanten efficiënter, schoner en veiliger te helpen bouwen. In de toekomst liggen er dan ook zeker opties voor verdere integratie van deze toepassing in andere processen, zoals in de productie van bouwtekeningen. Arvid: “De impact van deze innovatie is dat we grootschalig kunnen automatiseren, niet op één stukje, maar in het hele proces van klant tot oplevering.” 


JDZ_3184_11f0bdecbb.jpeg

Twenty times as many calculations

Twintig keer zoveel calculaties in dezelfde tijd

Super-fast modular configuration with no margin for error

Supersnel modulair configureren zonder foutmarge

With an application for ModuleMakers, a corporate start-up that emerged from tech giant Croonwolter&dros, LINKIT captured a complex engineering and calculation process in one handy program with the help of the OutSystems platform

Met een applicatie voor ModuleMakers, een corporate start-up die voortgekomen is uit tech-gigant Croonwolter&dros, ving LINKIT een complex engineerings- en calculatieproces in één handig programma met behulp van het OutSystems platform.

Twenty times as many calculations in the same amount of time

ahold-delhaize.png

Ahold Delhaize

Deutsche_Bahn_AG-Logo.svg

Deutsche Bahn

tfg logo.svg

TFG Transfracht

Speeding up development at these clients

Sneller ontwikkelen doen we bij deze klanten

Quickly replace a legacy application with OutSystems

Razendsnel een legacy applicatie vervangen met OutSystems

The use of the development platform OutSystems is increasing rapidly. The platform offers the possibility to create and start production business applications in a short time. However, in order to fully utilize the unique possibilities of OutSystems it is important to manage the platform properly, an aspect that often not expressed enough. In this article you will find a number of practical maintenance tips to make the most of your OutSystems platform!
 
### Infrastructure
OutSystems runs as a layer on top of an existing infrastructure. This can be servers that run in their own data centres, but virtual environments such as Azure and AWS are also possible. Depending on the chosen party, you are therefore responsible for the maintenance of your infrastructure.

### Platform
The biggest bottlenecks, however, arise mainly in the management of the platform itself. This often falls between two pillars. The infrastructure manager sees the maintenance of the OutSystems platform as a task for the application manager and vice versa. Both groups are wrong in this. It’s important to take the necessary steps for which specific knowledge is necessary in each case, otherwise the environment slowly but surely fills up and eventually, the applications slow down or give errors.

The management of the OutSystems platform can be divided into the following sections:

**1. Control in ServiceCenter on the various loggings and the "environment health".**

ServiceCenter shows the overall status of the platform. Here you will find the following loggings: Errors, General, Service Actions, Integrations, Processes, Mobile Apps, Environment Health and Security. Each of the logs provides more detail about the events that occurred in that area. ServiceCenter also provides an overview of all modules.

**2. Distribution of applications into different application pools**

The applications are deployed on a web server in IIS (can this be said in more easily understandable way?). By distributing the applications over multiple application pools, it is possible to reduce application clashing with each other as they request network resources..

 **3. Keeping and removing old application (versions)**

OutSystems offers the possibility to quickly try things out. This can lead to a proliferation of different applications that are no longer in use since they were only deployed as a test. Because of the overview and the space used, it is recommended to run through the applications from time to time and to clean up everything that was once made as a test.

**4. Track application analytics (LifeTime)**

In LifeTime there is an option to further analyse the applications. An application performance index score per application is shown – known as APDEX. It also shows how the time it takes to display a request is divided into client, network and server time. In this way, a developer can get started to improve the performance of areas that might seem to be underperforming.

*Do you want to know more about this subject? Then [read](https://itnext.io/beheer-outsystems-nuttig-of-noodzakelijk-e92d8347a90f) the long version of this article (in Dutch) on ITNEXT, the knowledge platform of LINKIT. Or contact author and OutSystems expert Kees Kleybeuker directly for more information.*


Het gebruik van het ontwikkelplatform OutSystems neemt een steeds grotere vlucht. Het platform biedt de mogelijkheden om in korte tijd business applicaties te maken en in productie te nemen. Maar om de unieke mogelijkheden van OutSystems voluit te benutten is het wel belangrijk om het platform goed te beheren, een onderdeel wat vaak onderbelicht blijft. In dit artikel vind je een aantal praktische onderhoudstips om jouw OutSystems platform optimaal te benutten! 

### Infrastructuur
OutSystems draait als een laag bovenop een bestaande infrastructuur. Dit kunnen servers zijn die in eigen datacenters draaien maar ook virtuele omgevingen zoals Azure en AWS zijn mogelijk. Afhankelijk van de gekozen partij ben je dan ook zelf verantwoordelijk voor het onderhoud van je infrastructuur. 

### Platform
De grootste knelpunten ontstaan echter vooral in het beheer van het platform zelf. Dit valt vaak tussen wal en schip. De beheerder van de infrastructuur ziet het onderhoud van het OutSystems platform als een taak voor de applicatiebeheerder en andersom. Beide groepen hebben in deze ongelijk. Je dient wel degelijk de noodzakelijk stappen te ondernemen waarvoor specifieke kennis noodzakelijk is. Anders loopt langzaam maar zeker de omgeving vol en worden uiteindelijk de applicaties trager of geven fouten.

Het beheer van het OutSystems platform is in de volgende stukken te verdelen:

**1.	Controle in ServiceCenter op de diverse loggings en de ‘environment health’.**

In ServiceCenter wordt de algehele status van het platform weergegeven. Je vindt hier o.a. de volgende loggings: Errors, General, Service Actions, Integrations, Processes, Mobile Apps, Environment Health en Security. Elk van de logs geeft meer detail over de gebeurtenissen die op dat gebied hebben plaats gevonden. ServiceCenter biedt ook het overzicht over alle modules heen. 

**2.	Verdeling van applicaties in verschillende applicationpools**

De applicaties worden gedeployed op een webserver in IIS. Door de applicaties te verdelen over meerdere applicatiepools is het mogelijk om invloeden van applicatie op elkaar (qua processor of CPU gebruik) te verminderen.

**3.	Bijhouden en verwijderen van oude applicatie (versies)**

OutSystems biedt de mogelijkheid om snel het een en ander uit te proberen. Dit kan leiden tot een wildgroei aan verschillende applicaties die niet (meer) gebruikt worden. Vanwege het overzicht en de gebruikte ruimte is het aan te bevelen van tijd tot tijd de applicaties langs te lopen en alles wat ooit als een test gemaakt is, weer op te ruimen.

**4.	Bijhouden applicatie analytics (LifeTime)**

In LifeTime is er een mogelijkheid de applicaties nader te analyseren. Hierbij wordt er een APDEX (Application Performance Index) score per applicatie weergegeven. Tevens is te zien hoe de tijd die nodig is om een request te tonen is opgedeeld in client-, netwerk- en servertijd. Zodoende kan een ontwikkelaar gericht aan de slag om de performance van onderdelen te verbeteren. 

*Wil je meer weten over dit onderwerp? Lees dan [de lange versie](https://itnext.io/beheer-outsystems-nuttig-of-noodzakelijk-e92d8347a90f) van dit artikel op ITNEXT, het kennisplatform van LINKIT. Of neem direct contact op met auteur en OutSystems expert Kees Kleybeuker voor meer informatie.*


OS-fourtips-1.png

With an OutSystems platform you can develop business applications in a short time. You will certainly get total control of the platform with these 4 tips.

Met een OutSystems platform kun je in korte tijd businessapplicaties ontwikkelen. Totale controle van het platform gaat je zeker lukken met deze 4 tips. 

OutSystems platform for developing apps quickly

OutSystems platform voor snelle app ontwikkeling

Four tips for maintenance and management of your OutSystems platform

Vier tips voor onderhoud en beheer van je OutSystems platform

What is your biggest peeve at the office? For many people, the answers usually include unreliable managers, bad coffee or jabbering colleagues. However, a poorly functioning IT system is often high on the list too, and this is a bit more complicated to resolve than a slow internet speed. Working with outdated, legacy applications that have been developed layer by layer over the years is a constant source of irritation for many people. IT is, therefore, an important point of attention for many companies. Malfunctioning and outdated applications not only cost a lot of money on maintenance but also reduce the ability of the employees to do their job effectively.
 
At the same time, modernizing the clumsy & clunky, old but extremely necessary legacy applications is easier said than done. So, is there a way to make this possible in a relatively easy way? Well, one way is by using a low-code platform such as OutSystems. That, in combination with the following 3 tips should help you get a good start on your journey.
 
### 1. Build the frontend first, then the backend
 
Building or modernizing an application with OutSystems is reverse engineering. With traditional programming languages you normally begin with a plan of what you’re going to make, then you build the backend and finally the frontend to meet that initial vision. Seen from a programmer's perspective this makes sense, but from a business point of view, this is tricky. After all, you would prefer to know as quickly as possible how certain functionalities work in practice so that you can easily adjust them where necessary.
  
This approach to this problem works differently with OutSystems. OutSystems offers the unique possibility to start right with the front end of the application. This is possible because the low-code platform works with templates and modules that pre-programmed. These are ready-to-use and immediately show what certain functionalities look like in practice.
 
In fact, because the development time is heavily reduced, you can have the user sitting next to you while you put something together. After getting the broad strokes complete in a short time, you can use the development time to work out the finer details.
 
### 2. Pick the low-hanging fruit first.
 
To get back to the intro of this article, legacy applications are undoubtedly the least user-friendly, most annoying and most complicated pieces of software you can come across. Sometimes they are so old that you must go back decades in the archives to discover why that one functionality works the way it does. That is, if that archive is still available. Working in four screens at the same time to perform one action is certainly no exception to the issues of these legacy applications. 
  
In short: asking end-users to come up with proposals for improvement is the same as asking a 5-year-old what he would like to receive from Santa. In other words, end-users are often full of ideas for improvement.  
  
### Rapid profit
 
Removing the frustrations of slow and cumbersome will improve the workflow of employees a huge amount, and with OutSystems it should take relatively little time to get tangible improvements. It also makes employees feel that they are taken seriously and are seeing real improvements in their work at a rapid pace. By automating certain actions in the background, they are relieved of work and can make better use of their time. An additional advantage is that you can quickly discover possibilities for new functionalities and improvements.
  
### 3. Integrate your applications and databases
  
Whilst modernizing an application, this is also a good opportunity to integrate it with various other applications and databases that work alongside that application. For example, employees often enter repetitive data, such as names and addresses into multiple databases. Why not integrate these databases so your employees do not have to continuously enter data four times in four different systems. These functions are automatically taken over from each other through integration. This is also very useful with databases. Combining data creates new insights into the behavior and needs of your customers, which you can apply in your business decisions.
 
With OutSystems it is relatively easy to implement integrations, both in the cloud and on-premise. It’s even possible that you keep the database of a legacy application up and running for longer, but already let it work via the new frontend.
  
*Would you like to know more about the possibilities of OutSystems for modernizing (legacy) applications? Then read our whitepaper [Replace a legacy application in no time with OutSystems](https://www.linkit.nl/en/articles/Modernize-your-application-You-do-it-with-these-3-tips!?whitepaper=open). Or contact one of our experts for more information.*


Wat is jouw grootste ergernis op kantoor? Voor veel mensen zijn dat onbetrouwbare managers en slechte koffie, maar ook slecht functionerende IT staat vaak hoog op de lijstjes. En dan gaat het niet alleen om traag internet. Ook het werken met verouderde applicaties die door de jaren heen laag over laag zijn uitgebouwd, zijn voor veel mensen een voortdurende bron van irritatie. Voor veel bedrijven vormt IT dan ook een belangrijk aandachtspunt. Slechtwerkende en verouderde **legacy systemen** kosten niet alleen veel geld aan onderhoud, maar verlagen ook de efficiëntie van de werknemers en zorgen dus voor veel frustraties.  

Tegelijkertijd is het moderniseren van het vaak logge, oude maar uiterst noodzakelijke legacy systeem makkelijker gezegd dan gedaan. Hoe het toch op een relatief makkelijke manier kan? Door low-code platform OutSystems te gebruiken, in combinatie met deze 3 tips, kom je hopelijk een heel eind! 

## Stap 1 bij een legacy systeem: pluk eerst het laaghangend fruit

Een legacy systeem bevat vaak de minst gebruiksvriendelijke, meest irritante en meest compliceerde stukken programmatuur die je tegen kunt komen. Soms zijn ze zo oud dat je tientallen jaren terug moet in de archieven om te ontdekken waarom die ene functionaliteit werkt zoals hij werkt. Werken in vier schermen tegelijk om één handeling uit te voeren is zeker geen uitzondering.  

Kortom: eindgebruikers vragen om met verbeter voorstellen te komen is hetzelfde als een 5-jarige vragen wat hij graag van Sinterklaas wil krijgen. Het kost zelden veel moeite.  

**Snelle winst **
Tegelijkertijd levert het wegnemen van deze frustraties wel enorm veel op. Terwijl het met OutSystems relatief weinig tijd hoeft te kosten. Werknemers voelen zich serieus genomen en zien in hoog tempo ook daadwerkelijke verbeteringen in hun werk. Door op de achtergrond bepaalde handelingen te automatiseren wordt hen werk uit handen genomen en kunnen ze hun tijd beter benutten. Een extra voordeel is dat je mogelijkheden voor nieuwe functionaliteiten en verbeteringen snel kunt ontdekken.  

## 2.	Bouw eerst de frontend, dan de backend

Een applicatie bouwen, of moderniseren met OutSystems is reverse engineering. Bij traditionele programmeertalen maak je normaal gesproken eerst een plan, bouw je daarna de backend en tot slot de frontend. Vanuit een programmeur bekeken is dit logisch, maar vanuit de business gezien is dit lastig. Je wilt tenslotte het liefst zo snel mogelijk weten hoe bepaalde functionaliteiten in de praktijk werken, zodat je ze waar nodig nog makkelijk aan kunt passen.  

Bij OutSystems werkt dit anders. Het biedt de unieke mogelijkheid om juist te beginnen met de frontend van de applicatie. Dit kan omdat het low-code platform met templates en modules werkt. Deze zijn kant-en-klaar en laten direct zien hoe bepaalde functionaliteiten in de praktijk eruit zien.  
Sterker nog; omdat de ontwikkeltijd vele malen lager ligt, kun je de gebruiker naast je hebben zitten terwijl je iets in elkaar knutselt. Na het razendsnel bouwen van de grote lijnen, kun je de ontwikkeltijd gebruiken voor het uitwerken van de details.     

## 3.	Integreer je applicaties en databases

Bij het moderniseren van een legacy systeem wil je de kans niet missen om deze te integreren met diverse andere applicaties en databases. Zo hoeven werknemers bijvoorbeeld niet continu gegevens viermaal in te vullen in vier verschillende applicaties. Door integratie worden die automatisch van elkaar overgenomen. Ook bij databases is dit zeer handig. Door data met elkaar te combineren ontstaan nieuwe inzichten in het gedrag en de behoeftes van je klanten die je kunt toepassen in je beslissingen.

Met OutSystems is het relatief makkelijk om integraties aan te leggen. Zowel in de cloud als on premise. Hierbij is het zelfs mogelijk dat je de database van een legacy applicatie langer in de lucht houdt, maar deze al wel laat werken via de nieuwe frontend.  

*Wil je meer weten over de mogelijkheden van OutSystems voor het moderniseren van (legacy)applicaties? Lees dan ons whitepaper [Razendsnel een legacy-applicatie vervangen met OutSystems](https://www.linkit.nl/articles/Jouw-applicatie-moderniseren-Je-doet-het-met-deze-3-tips!?whitepaper=open). Of neem contact op met één van onze experts voor meer informatie.*


programmer-cooperating-working-web-site-project-software-developing-desktop-computer.jpg

Replace your legacy system by using low-code platform OutSystems. You can easily do it with these 3 tips!

Legacy systeem vervangen door low-code platform OutSystems te gebruiken? Met deze 3 tips, kom je een heel eind! 

Modernize your legacy application with low-code

Legacy systeem moderniseren met low-code

Modernize your application? You can do it, with these 3 tips!

Jouw applicatie moderniseren? Je doet het, met deze 3 tips!

Whitepaper: replacing legacy applications by using OutSystems

Whitepaper: legacy-applicaties vervangen met behulp van OutSystems

Within IT, speed has been high on the agenda for many years. There are a number of reasons for this. For a start, IT professionals are not only expensive, but also rare. By [working more efficiently you not only reduce costs](https://www.leapwork.com/blog/3-ways-to-reduce-software-development-costs-for-the-c-suite), you can also take on more projects and as an IT company you don't have to pay for time where there are no projects. The advantages are evident for the clients. At LINKIT we have been using a golden combination for a number of years: developing low code in OutSystems according to the Scrum method. One plus one is three, according to our developers. What is the secret behind that?

### Scrum
To begin with an explanation of Scrum, this working method was developed around the 1990s and is best known for working in short so-called "sprints". These are periods of one or two weeks in which clearly defined tasks are performed within a team, in which multiple skillsets are always represented. For example, that of .NET developer or a data engineer. After that, there is an evaluation, in which the 'product owner', the representative of the client, has the opportunity to make adjustments before the next sprint starts. In contrast to the time-honoured waterfall method, as a client you are much closer to the implementation with Scrum. Not only are people working faster, but the chance of mistakes is also considerably lower.

### OutSystems
OutSystems in turn has been developed as a low code platform to develop new applications at lightning speed. This is mainly because programming in this environment is largely done visually. Frequently used features or pieces of code are pre-programmed and can simply be dragged one after the other. This makes it possible to deliver a working prototype within a few hours. Depending on the requested complexity, a project can be delivered within a few days or weeks.

Scrum is primarily intended as a method to perform a slow way of programming faster. But what does it yield if you combine it with a development method that is very fast in itself.

### Scrum at high speed
Our experience is that it produces results at twice the speed. By working according to the Scrum method, you get the maximum efficiency from the development possibilities of OutSystems. Because the development is so fast, it is advisable to shorten the time of each sprint. For example to a week instead of two weeks. By using OutSystems, the waiting time of the product owner is drastically reduced and the entire process can be completed at lightning speed. Scrum, but at high speed.

### Excellent results
The Scrum method is very suitable for maintaining control within a very rapid development process and, as the client, ensuring that the optimum result are delivered very quickly. At LINKIT we achieve excellent results with this, leading to satisfied clients. More about this you can read [in our business case](/en/cases/How-Intratuin-"grows-and-flourishes"-again-with-OutSystems) 'How Intratuin "grows and florishes" again with OutSystems'.

*Are you interested in the possibilities of a project executed through this dream combination? Please contact one of our experts for more information?*


Binnen de IT staat de ontwikkelsnelheid al een aantal jaar hoog op de agenda. Dit heeft een aantal redenen. Zo zijn IT-professionals niet alleen duur, maar ook zeldzaam. Door efficiënter te werken druk je niet alleen de kosten, maar kun je ook meer projecten aannemen en hoef je als IT-bedrijf minder vaak ‘nee, geen tijd’ te verkopen. Ook voor de opdrachtgevers zijn de voordelen evident. Bij LINKIT maken we sinds een aantal jaren gebruik van een gouden combinatie: low code ontwikkelen in OutSystems door Agile te werken. Één plus één is drie, volgens onze ontwikkelaars. Wat is het geheim daarachter?  

## Agile 
Om bij Agile te beginnen: deze werkmethode is rond de jaren ’90 ontwikkeld. Het hoofdonderdeel is het zogenaamde [Agile Manifesto](https://agilemanifesto.org/). Agile werken kan op meerdere manieren, maar is vooral bekend vanwege het werken in korte ‘sprints’. Periodes van één of twee weken waarin duidelijke omschreven taken binnen een team worden uitgevoerd, waarbinnen altijd meerdere skillsets zijn vertegenwoordigd. Bijvoorbeeld die van .NET developer of data engineer. Daarna volgt altijd een evaluatie, waarna de ‘product owner’, de vertegenwoordiger van de opdrachtgever, de mogelijkheid heeft om bij te sturen voordat de volgende sprint begint. In tegenstelling tot de aloude watervalmethode zit je als opdrachtgever met Agile veel dichter op de uitvoering. Niet alleen wordt er sneller gewerkt, maar ook de kans op fouten is fors lager. Een van de bekendste Agile werkmethodes is Scrum. 

## OutSystems
OutSystems op zijn beurt is ontwikkeld als een low code platform om razendsnel nieuwe applicaties mee te ontwikkelen. Dit kan vooral doordat het programmeren in deze omgeving grotendeels visueel gebeurt. Veelgebruikte features, of stukken code zijn voorgeprogrammeerd en kunnen simpelweg achter elkaar worden gesleept. Dit maakt het mogelijk om al binnen een paar uur een werkend prototype op te leveren. Afhankelijk van de gevraagde complexiteit kan een project binnen enkele dagen of weken worden opgeleverd.  

Agile is vooral bedoeld als methode om een langzame manier van programmeren sneller uit te voeren. Maar wat levert het op als je het combineert met een ontwikkelmethode die op zichzelf al heel snel is?  

## OutSystems met Agile in sneltreinvaart 
Onze ervaring is dat het een dubbele groeiversneller is. Door Agile te werken, haal je de maximale snelheid uit de ontwikkelmogelijkheden van OutSystems. Omdat het ontwikkelen zo snel gaat is het wel aan te raden om de tijd van iedere sprint flink te verkorten. Bijvoorbeeld naar een week in plaats van twee weken. Door OutSystems te gebruiken wordt de wachttijd van de product owner drastisch verkort en kan het volledige traject in razendsnel tempo worden afgelegd. Agile, maar dan in sneltreinvaart.   

## Uitstekende resultaten OutSystems en Agile 
Agile is zeer geschikt om binnen een zeer snel ontwikkelingstraject toch de controle te behouden en er als opdrachtgever zeker van te zijn dat het optimale resultaat zeer snel wordt opgeleverd. Bij LINKIT bereiken we hier uitstekende resultaten mee, met zeer tevreden opdrachtgevers als gevolg, zoals ook te lezen is in deze [business case](/cases/Hoe-Intratuin-weer-'groeit-en-bloeit'-met-OutSystems).

*Heb je interesse in het (laten) uitvoeren van een project via deze droomcombinatie? Neem dan contact op met één van onze experts voor meer informatie?*


OS-Scrum.jpg

Why Scrum and OutSystems are a business dream couple.Discover together with us why, according to our developers one plus one is three.

Waarom zijn Agile werken & OutSystems een droomcombinatie? Ontdek waarom volgens onze developers 1 plus 1 dan ook 3 is! 

Uitstekende en snelle resultaten OutSystems en Agile werken

Why Scrum and OutSystems are a business dream couple

Waarom OutSystems en Agile werken een bedrijfskundig droompaar vormen 

Articles to get you started

Low-code artikelen om je op weg te helpen

OutSystems developer

Orla Dijkink 2.jpg

Orla Dijkink.jpg

Lead Mendix

Bob_van_Heijster_c_ac84cc0f0c.jpeg

Bob_van_Heijster_c_sq_7d3299c138.jpeg

Our Low-code heroes

Onze Low-code helden

Building an app in OutSystems. Is that coding or configuring? This idea was discussed at the program table of the Vechtstromen water board. In essence, the conversation was about a new OutSystems app that the water board built in-house, with support from LINKIT. The water board is very enthusiastic about both the result and the work process that resulted the unique properties of OutSystems.

### The case
The sewage treatment plants (WWTP) of the Vechtstromen water board used an application by Riloss for the logistics process surrounding the raw materials of a treatment plant for many years. However, the supplier of this application has not existed for years, resulting in the organization using a lot of time, and therefore money, to keep the application running. In addition, the risk that the application as a whole no longer functioned was increasing as the environment, such as the OS, on which the application is running  continued.

### Higher reporting requirements
What made this challenge even bigger was that the reporting requirements have increased considerably in legislation and internal needs, something Riloss could not support either. It became apparent that both the wishes surrounding the process as well as new current possibilities in technology have changed in such a way that considerable improvement could be achieved by replacing the app.

### Develop in-house
The replacement app, ChemLog, needed to be built in OutSystems. These days it’s is relatively simple to outsource that process to a third party, but the water board had decided against that. By developing it themselves, they wanted to keep a better grip on the development and management costs and hoped this approach would result in an app that is more future-proof. In addition, self-development makes it easier to link Chemlog to other applications while being able to further develop them.

### Two goals
Learning to program with OutSystems thus became almost as important a goal as creating the new app and LINKIT support was chosen to help guide the customer through this. With a department of over 30 OutSystems developers, we have more than enough in-house knowledge and experience to assist in this process.

### Scrum
An important part of that guidance was the introduction of Scrum into the work process. What this means is that the entire development process was divided into short, objective sprints and the communication of goals was clearly organized.
 
### User stories
In addition, the water board wrote a user story for each piece of the application's functionality. Each of them has been in mind through the development process. This resulted in a close and constant cooperation with the end users of the water board, ensuring desired quality as all the functionalities have been tested on all desired platforms by the programmer as well as gaining the approval from the users themselves.
  
### Better than imagined
It a short period, the newly trained OutSytems programmers of the water board had a good grasp of OutSystems. Programming with OutSystems is largely done visually, by putting pre-programmed pieces of code one after the other. This makes work up to eight times faster and the margin of error is also a lot lower. After an introduction period by LINKIT, the water board was able to build most of the application itself. A huge advantage to the customer.

Soon the results could be realised for the customer. In just three weeks, a fully functioning application was delivered that meets all requirements.
 
### Developing yourself has benefits
Developing an application in-house with low-code fits in well with the philosophy of the digital transformation that the water board is undergoing, as being adaptive is an important requirement. If the wishes and requirements change in the future, the application can now change relatively easily as all the needed knowledge is in-house. Chemlog can also implement innovative ideas, such as automatic orders of raw materials by placing sensors at raw material tanks. In the end, the OutSystems platform and the applications running on it grow with the wishes and needs of the customer. This prevents a legacy application such as Riloss from arising again.
 
### Positive result
The project has now been completed and LINKIT have switched to an administrator role. When the results were shared with the same program table of the water board that previously wondered whether OutSystems is really programming, their response was very positive on both the progress and on the final results. Thanks to very positive feedback from the organization, meeting the schedule and staying well within budget, the program table was pleased. 

### LINKIT
The cooperation with the water board was also interesting for LINKIT. For us it is a new confirmation of the power and possibilities of programming with OutSystems. The fact that a group of programmers without knowledge of OutSystems can turn it into a complete app in no time gives a clear message!

*Could you also benefit from such a transformation? At LINKIT we would be happy to guide you! Contact one of our experts for more information.*


Een low code applicatie bouwen met OutSystems. Is dat nou coderen, of juist configureren? Daarover ging een discussie aan de programmatafel van het waterschap Vechtstromen. Breder ging dit gesprek over een nieuwe OutSystems app die het waterschap in eigen beheer heeft gebouwd, met ondersteuning van LINKIT. Het waterschap is zeer enthousiast over zowel het resultaat als het werkproces en dat heeft alles te maken met de unieke eigenschappen van OutSystems.

## De case
De rioolwaterzuiveringsinstallaties (RWZI) van waterschap Vechtstromen gebruikten voor het logistieke proces rondom de grondstoffen van een zuivering jarenlang de applicatie Riloss. De leverancier van deze applicatie bestaat echter al jaren niet meer. Hierdoor kostte het de organisatie veel tijd, en dus geld, om de applicatie draaiende te houden. Bovendien nam het risico dat de applicatie in zijn geheel niet meer functioneerde steeds verder toe omdat de omgevingen waarop de applicatie draait wel (moeten) door ontwikkelen.

## Hogere rapportage-eisen
Om het probleem nog groter te maken zijn de laatste jaren ook de rapportage-eisen zowel vanuit wetgeving als intern een stuk groter geworden. Ook hieraan kon Riloss niet voldoen. Tot slot zijn zowel de wensen rondom het proces als de hedendaagse mogelijkheden dusdanig veranderd dat er flinke efficiencywinst te behalen was door de app te vervangen.

## Low code applicatie ontwikkelen in eigen beheer
En die vervanger, ChemLog, dat moest een in OutSystems gebouwde low code app worden. Nu is het relatief simpel om dat proces uit te besteden aan een derde partij, maar dat wilde het waterschap bewust niet. Door zelf te ontwikkelen wilden ze meer grip houden op de ontwikkel- en beheerkosten en hoopten ze dat de app toekomstbestendiger zou zijn. Daarnaast maakt zelf ontwikkelen het makkelijker om Chemlog te koppelen aan andere applicaties en deze verder door te ontwikkelen. 

## Twee doelen 
Leren programmeren met OutSystems werd zodoende bijna net zo’n belangrijk doel als het creëren van de nieuwe app. Als ‘leermeesters’ werd gekozen voor ondersteuning van LINKIT. Met een afdeling van ruim 30 OutSystems developers hebben we meer dan genoeg kennis en ervaring in huis om een dergelijk traject te begeleiden. 

## Scrum
Een belangrijk onderdeel van die begeleiding was de introductie van Scrum in het werkproces. Hierdoor werd het hele ontwikkelingstraject opgeknipt in korte sprints en werd bovendien de onderlinge communicatie duidelijk ingericht. 

## User stories 
Daarnaast werd door het waterschap voor ieder stukje functionaliteit van de low code applicatie een user story geschreven. Elk daarvan heeft de ontwikkelstraat doorlopen. Dit zorgt voor een nauwe en constante samenwerking met de eindgebruikers van het waterschap en garandeert een stuk kwaliteit omdat alle gemaakte functionaliteiten op alle gewenste platformen getest zijn, door een andere programmeur zijn nagekeken en uiteindelijk door de gebruiker getest en akkoord bevonden zijn. 
 
## Beter dan gedacht
Al snel bleken de nieuwbakken OutSytems programmeurs van het waterschap prima uit de voeten te kunnen met OutSystems. Programmeren met OutSystems gebeurt namelijk voor een groot deel visueel, door voorgeprogrammeerde stukken code achter elkaar te zetten. Hierdoor gaat het werk tot wel acht keer sneller en is de foutmarge ook een heel stuk lager. Na een inwerkperiode door LINKIT kon het waterschap het grootste gedeelte van de applicatie zelf bouwen. Een flinke meevaller.   

Het resultaat mocht er vervolgens zijn. In slechts drie weken tijd werd een volledig functionerende applicatie opgeleverd die voldoet aan alle wensen. 

## Voordelen zelf ontwikkelen low code applicatie 
Het zelf low-code ontwikkelen van een applicatie past goed in het gedachtegoed van de digitale transformatie die het waterschap doormaakt. Adaptief zijn is daarbij namelijk een belangrijke eis. Als de wensen en eisen in de toekomst veranderen, kan de applicatie nu relatief makkelijk mee veranderen. Alle kennis zit tenslotte in eigen huis. Ook kan Chemlog eventueel worden uitgebreid met innovatieve onderdelen, zoals automatische bestellingen van grondstoffen door sensoring te plaatsen bij grondstoftanks. Tot slot groeit het OutSystemsplatform en dus ook de applicaties die erop draaien met hun tijd mee. Hierdoor wordt voorkomen dat er weer een?legacy-applicatie?zoals Riloss ontstaat. 

## Positief resultaat 
Inmiddels is het project afgerond en zijn we overgestapt op een beheerdersrol.   De resultaten zijn gedeeld met diezelfde programmatafel van het waterschap die zich eerder afvroeg of OutSystems wel echt programmeren is. Hun reactie was zeer positief. Zowel op het verloop als op  de uiteindelijke resultaten. Dit kwam mede door de erg positieve feedback vanuit de organisatie, het halen van de planning en het ruim binnen budget blijven.

## LINKIT
Ook voor LINKIT was de samenwerking met het waterschap interessant. Voor ons is het een nieuwe bevestiging van de kracht en de mogelijkheden van programmeren met OutSystems. Het feit dat een groep programmeurs zonder kennis van OutSystems er wel binnen de kortste keren er een complete app van kunnen maken geeft een duidelijke boodschap af! 

*Heb jij ook interesse in een dergelijke vorm van samenwerking. Bij LINKIT staan we daar zeker voor open! Neem contact op met één van onze experts voor meer informatie.*

OS-vechstromen.jpg

Building an app for a logistical process for purifying water in just 3 weeks? You can with OutSystems! Discover how this was done within time & budget!

In 3 weken een low code applicatie bouwen voor het logistieke proces van het Waterschap? Dat kan met OutSystems! Ontdek hoe dit binnen de tijd en budget lukte!

Low code applicatie bouwen in 3 weken!

Support the construction of the OutSystems app for the logistics process at the Vechtstromen water board

Ondersteunen bouw OutSystems app voor het logistieke proces bij waterschap Vechtstromen 

Building a low code application in (almost) 3 weeks

In 3 weken (bijna) zelf een low code applicatie bouwen

Just as consumers buy their products online, supermarkets also have to buy their products or request new articles for their assortment from a distance. For many this is done centrally. The chain is organized in such a way that every country orders their products at the supermarket headquarters. Mainly done by sending emails or filing request forms. This takes a lot of time and money and is also prone to mistakes. 

A German supermarket holding recently asked LINKIT to look into this and to build a PoC (Proof of Concept) to validate a better way of requesting new products to be added to the product range. With a simple web app it is possible to directly order products from a catalogue, with most of the requested data automatically filled in. Doing so, every supermarket purchaser can choose from all possible products the chain has to offer. A supermarket for the supermarket.

### Saving time and effort

Previously, processing numerous requests from all over the world was a full-time job for ten to 15 people at the supermarket’s office. In total, ten to twelve fields have to be filled in before a single request can be carried out. Next to this, when everything is requested by mail or standalone forms, there is a significant chance of missing vital information. 

At some point, two managers came with a proposal to innovate this process and make life easier for everyone. LINKIT got the assignment to build a PoC of this app in low code. The purpose? To verify if an app would really be the simple solution the managers had in mind and if low code is the go-to solution.

### The beginning of a PoC

Building a PoC is not just a technical challenge, explains LINKIT’s Solution Advisor Jimmy Iliohan. He was closely involved in this project. “It is also a challenge to make the right selection of functionalities to be implemented. Building a PoC only requires a short amount of time, ten days, in which we need to prove the concept. This means we need to focus on one or two of the core functionalities and leave out everything else. To figure this out we kicked off the PoC with a design workshop, together with the product owners from the supermarket chain.”

“To distinguish the nice from the necessary we divided all functionalities (or user stories) into categories”, Jimmy adds. “Those which were easy to implement and would have the greatest impact on the application were our main focus. Next to this, there were some criteria we had to decide upon: the minimum requirements we had to build to be able to confirm success. They also have to be included of course.”

### Adapting to reality

The workshop led to a different outcome compared to our starting point. Jimmy explains: “Originally the idea was to build an Instagram like catalogue where you could not just order products, but also swipe through them and like them. For the PoC this was way too fancy. Therefore, we would focus on just the ordering mechanism eventually.”

### Developing a solution in low-code

LINKIT’s OutSystems developer, Abeer El Assal, was also involved during the whole process. “Using low code for a PoC is a smart choice,” she says. “Unlike any other technology available, low code makes it possible to create an app amazingly fast. This is because it works with ready-made pieces of code you can drag and drop, instead of having to write everything from scratch. By pulling everything in the right logical order you can come up with a fast model to test the main functionalities. Stakeholders from the supermarket helped by providing some mock-ups for the design we could use as a start.” 

### Progressive Web Apps as an alternative

For Abeer, this made it easy to work. “We build the app as a Progressive Web App. Unlike a normal (native) app, you don’t download a PWA on your phone. It functions as a website on your browser, but with the extra functionality that you can add it as a direct link on your phone. It appears on your screen just like any normal app.” 

“That doesn’t mean it's simple to build,” she continues. “PWA’s have their own perks. One of them we noticed when we wanted to include push notifications. For example, when you have filed a request and got an approval or denial. For Android, we could work this out, but not for IOS. They have made it impossible for a PWA to send any messages directly into their system, so we had to find a workaround. Eventually we chose to send SMS-messages instead, which also does the trick.”

### The result 

After fifteen days the PoC was finished. A little late one might think, but LINKIT decided to extend the ten days themselves to deliver more value. The next step was the final review in which the product owners give feedback on the result. For Jimmy this was one of the more exciting moments of building a PoC. “Luckily, we got particularly good feedback.”

### What happens after a successful Proof of Concept?

The main reason to carry out a PoC is obviously to see if there is Proof for the Concept. This will decide what will happen next. According to Jimmy there are three possible scenarios: “It works and we will expand the PoC into a MVP, a Minimum Viable Product. Or, nr. 2, it doesn’t work, but we think we can make it work. Or, nr. 3, it completely fails and we stop working on the PoC.”

Jimmy continues: “Often a PoC is a success, but sometimes it doesn’t. That doesn’t mean you have thrown away your investment. Especially for bigger projects and IT investments it is already worthwhile if only one out of ten PoC’s is successful. It is a great way to explore new innovational concepts against limited investments. And to assure more business for your company.”  

*Are you also interested in building a PoC for one of your innovational concepts? We can help! Get in touch with one of our experts for more information.*


Net zoals consumenten hun producten online kopen, moeten ook supermarkten hun producten ergens inkopen of aanvragen. Vaak gebeurt dit centraal. De keten is dan zo georganiseerd dat elk land zijn producten bij het hoofdkantoor van de supermarkt bestelt. Meestal door het verzenden van e-mails of het indienen van aanvraagformulieren. Dit kost echter veel tijd en geld en is ook nog eens foutgevoelig.

Een Duitse supermarktholding vroeg LINKIT onlangs om een PoC (Proof of Concept) te bouwen om een betere manier van bestellen te valideren. De vraag daarbij: is het mogelijk om met een eenvoudige webapp direct producten uit een catalogus te bestellen, waarbij de meeste gevraagde gegevens al automatisch worden ingevuld? Zo kan iedere supermarktkoper makkelijk kiezen uit alle mogelijke producten die de keten te bieden heeft. Een supermarkt voor de supermarkt dus.

### Tijd en moeite besparen

Het verzoek kwam niet voor niets. Het verwerken van talloze verzoeken van over de hele wereld is een fulltime baan voor tien tot vijftien mensen op het kantoor van de supermarkt. In totaal moeten iedere keer tien tot twaalf velden worden ingevuld voordat een enkele aanvraag kan worden uitgevoerd. Daarnaast is er, wanneer alles per post of losse formulieren wordt opgevraagd, een grote kans op het ontbreken of foutief invullen van belangrijke informatie.

### Het begin van een PoC

Het bouwen van een PoC is niet alleen een technische uitdaging, legt LINKIT's Solution Advisor Jimmy Iliohan uit. Hij was nauw betrokken bij dit project. “Het is ook een uitdaging om precies de juiste selectie te maken van de functionaliteiten die echt noodzakelijk zijn. Het bouwen van een PoC gebeurt namelijk in slechts tien dagen, waarin we het concept moeten bewijzen of ontkrachten. Dit betekent dat we ons moeten concentreren op één of twee van de kernfunctionaliteiten en al het andere moeten weglaten. Om daar achter te komen hebben we de PoC afgetrapt met een design workshop, samen met de product owners van de supermarktketen.”

“Om het mooie van het noodzakelijke te onderscheiden, hebben we alle functionaliteiten (of user stories) onderverdeeld in categorieën”, legt Jimmy uit. “Daarbij hebben we vooral gekeken naar stories die makkelijk te implementeren zijn, maar tegelijkertijd veel waarde opleveren.  Daarnaast waren er enkele criteria die we moesten bepalen: de minimale vereisten die we moesten bouwen om de PoC te laten werken. Die kwamen er natuurlijk ook bij.”

### Aanpassen aan de realiteit

“De workshop leidde tot een andere uitkomst dan ons uitgangspunt,” legt Jimmy uit: “Oorspronkelijk was het idee om een Instagram-achtige catalogus te bouwen waar je niet alleen producten kon bestellen, maar er ook doorheen kon swipen om ze te ‘liken’. Voor de PoC was dit veel te luxe. Daarom hebben we ons uiteindelijk beperkt tot alleen het bestelmechanisme.”

### Een oplossing ontwikkelen in low-code

Ook LINKIT’s OutSystems developer Abeer El Assal, was bij het hele proces betrokken. “Low code gebruiken voor een PoC is een slimme keuze”, zegt ze. “In tegenstelling tot elke andere beschikbare technologie, maakt low code het mogelijk om verbazingwekkend snel een app te maken. Dit komt omdat het werkt met kant-en-klare stukken code die je kunt slepen en neerzetten, in plaats van alles volledig te coderen. Door alles in de juiste logische volgorde te zetten kun je snel een applicatie bouwen om de belangrijkste functionaliteiten mee te testen. Enkele designers van de supermarkt hielpen mee door mock-ups te maken voor het ontwerp.”

### Progressive Web Apps als alternatief

Dit maakte het voor Abeer gemakkelijk om te werken. “We hebben direct voor een Progressive Web App (PWA) gekozen. In tegenstelling tot een normale (native) app download je een PWA niet direct op je telefoon. Het functioneert als een website in je browser, maar met de extra functionaliteit dat je het als een directe link op je telefoon kunt toevoegen. Het verschijnt op je scherm, net als elke normale app.”

"Dat betekent niet dat het eenvoudig te bouwen is", vervolgt ze. “PWA’s hebben zo hun  eigenaardigheden. Één daarvan merkten we toen we pushmeldingen wilden opnemen. Bijvoorbeeld wanneer je een verzoek hebt ingediend en een goedkeuring of afwijzing hebt gekregen. Voor Android is dit geen probleem, maar wel bij IOS (Apple). Zij hebben het een PWA onmogelijk gemaakt om berichten rechtstreeks naar hun systeem te sturen, dus moesten we een oplossing vinden. Uiteindelijk hebben we ervoor gekozen om sms-berichten te sturen, wat ook werkt.”

### Het resultaat

Na vijftien dagen was de PoC klaar. Meer dan gepland, maar LINKIT besloot de tien dagen zelf te verlengen om meer waarde te kunnen leveren. De volgende stap was de eindbeoordeling waarin de producteigenaren feedback geven op het resultaat. Voor Jimmy was dit één van de spannendste momenten van het bouwen van een PoC. “Gelukkig kregen we bijzonder goede feedback.”

### Wat gebeurt er na een succesvolle Proof of Concept?

De belangrijkste reden om een PoC uit te voeren is natuurlijk om te kijken of er Proof for the Concept is. De uitkomst bepaalt dan wat er verder gebeurt. Volgens Jimmy zijn er drie mogelijke scenario's: “Het werkt en we zullen de PoC uitbreiden tot een MVP, een Minimum Viable Product. Of, optie 2, het werkt niet, maar we denken dat we het kunnen laten werken. Of, nr. 3, het mislukt volledig en we stoppen met werken aan de PoC.”

Jimmy vervolgt: “Vaak is een PoC een succes, maar soms ook niet. Dat betekent niet dat je de investering hebt weggegooid. Zeker voor grotere projecten en IT-investeringen is het al de moeite waard als slechts één op de tien PoC’s succesvol is. Het is een geweldige manier om nieuwe innovatieve concepten te verkennen tegen beperkte investeringen. En om meer en nieuwe business voor je bedrijf te creëren.”

*Ook geïnteresseerd in het bouwen van een PoC voor een van jouw innovatieconcepten? Wij kunnen helpen! Neem voor meer informatie contact op met één van onze experts.*


good-looking-woman-standing-front-vegetable-shelves-choosing-what-buy.jpg

Executing a Proof of Concept for an app to easily request new products

Uitvoeren van een Proof of Concept voor een app om eenvoudig nieuwe producten aan te vragen

Building a supermarket for supermarkets in low code

Een supermarkt voor supermarkten bouwen in low-code

How do you manage the colossal logistics processes at a garden center giant such as Intratuin? As a visitor you don't get to see much of it, but behind the scenes there is a system busy with continuous scanning, measurement and re-ordering of products and orders. This is a repetitive process that can realise a lot of benefits from automation of those actions. At Intratuin a large part of the orders go through their internal ordering app Winkelportaal. In 2019 LINKIT contributed to a major upgrade, which significantly improved both the possibilities and the logistics processes.

### Intratuin
Intratuin is one of the largest garden centers in the Netherlands, Belgium and Germany, with 65 franchise stores. Their total offering consists of 80,000 different products that are sold to 12.5 million visitors per year.

### The importance of the application
The franchisees manage stock by ordering all inventory, except plants and animals, directly from Intratuin via the Store Portal application. Initially, this was first built up low code with Mendix, but many essential functionalities were missing. For example, there was no Android app, not all product groups could be ordered and there was insufficient integration with the Zebra barcode scanners that Intratuin employees use in the store and during fairs or trade shows.

### LINKIT
In order to help bring these processes more tightly together, Intratuin decided to completely rebuild its portal. This time OutSystems was chosen, bringing LINKIT into the picture. Two of our OutSystems developers participated in the project, led by OutSystems lead developer Diana van Eijk.

### All systems in one app
Diana: “As a team, we first have to understand all the processes and needs of the customers for the new app, in this case it was the commercial managers of the sites. Task number one was to connect all underlying systems to each other through the new Shopping Portal. We have solved this problem with the recently developed SOAP (Simple Object Access Protocol) from Microsoft BizTalk. ”

### Integration with Zebra scanners
“A second point of attention was the integration with the scanners. These are crucial in the entire logistics process, because they keep track of how many products are still in stock. After all, every time the cash register scans something, it has to be ordered again. Moreover, it does not stop at the cash registers. During events that Intratuin organizes, the progress of the stock is monitored with scanners. With the new integration, this is much faster and many repetitive steps have been automated that were previously taking a lot of time. ”

 
### Working agile saves time
Perhaps the most important contribution of Diana was not technical per se. “The entire development process was originally set up according to the waterfall method, so as one big whole. I have tried to convert this bit by bit into an Agile approach. This made development a lot faster. Together with the rapid development time associated with OutSystems, we have succeeded in delivering the application much faster than planned. ”

*Do you also have an app that needs to be replaced or can use an upgrade? We are happy to think along with you about a suitable solution. Please contact one of our experts for more information. Or read our [whitepaper](https://www.linkit.nl/en/cases/How-Intratuin-%22grows-and-flourishes%22-again-with-OutSystems?whitepaper=open) about replacing legacy applications using OutSystems.*

Image: Marion Golsteijn

Hoe beheer je het kolossale logistieke proces bij een tuincentergigant zoals Intratuin? Als bezoeker zie je daar niet veel van, maar achter de schermen wordt er continu gescand, gemeten en weer bijbesteld. Een repeterend proces dat ongelooflijk kan profiteren van automatisering. Bij Intratuin gaat een groot gedeelte van de bestellingen via hun interne bestelapp Winkelportaal. LINKIT hielp mee aan het heropbouwen van het portaal waardoor zowel de mogelijkheden als de logistieke processen fors zijn verbeterd. 

## Intratuin
Intratuin is met 65 franchisewinkels één van de grootste tuincentra van Nederland, België en Duitsland. Hun totale aanbod bestaat uit 80.000 verschillende producten die worden verkocht aan 12,5 miljoen bezoekers per jaar. 

## Het belang van het portaal
Als onderdeel van de werkovereenkomst moeten de franchisenemers alle voorraad, behalve planten en dieren, direct bij Intratuin bestellen via de applicatie Winkelportaal. Daar ontbraken echter een aantal belangrijke functionaliteiten. Zo was er geen Android app, konden niet alle productgroepen besteld worden en was er onvoldoende integratie met de Zebra barcode scanners die Intratuin werknemers in de winkel en tijdens fairs gebruiken.

## Portaal opnieuw bouwen
Om dit voor elkaar te krijgen besloot Intratuin haar portaal volledig opnieuw op te bouwen. Deze keer werd er gekozen voor OutSystems, waardoor LINKIT in beeld kwam. Twee van onze OutSystems developers werkten mee aan het project, onder leiding van OutSystems lead developer Diana van Eijk.  

### Alle systemen in één app 
Diana: “Voor de nieuwe app hebben we als team eerst alle processen en behoeftes van de klanten, in dit geval de commercieel managers van de vestigingen. Opdracht nummer één was om alle onderliggende systemen met elkaar te verbinden door het nieuwe Winkelportaal. Met de recent ontwikkelde SOAP (Simple Object Acess Protocol) van Microsoft BizTalk hebben we dit probleem opgelost.”

### Integratie met Zebra scanners
“Een tweede punt van aandacht was de integratie met de scanners. Die zijn cruciaal in het hele logistieke proces, omdat daarmee wordt bijgehouden hoeveel producten er nog in de voorraad zitten. Iedere keer als de kassa iets scant, moet dat tenslotte ook weer worden bijbesteld. Bovendien houdt het niet op bij de kassa’s. Ook tijdens evenementen die Intratuin organiseert wordt het verloop van de voorraad met scanners bijgehouden. Met de nieuwe integratie verloopt dit veel sneller en zijn veel repeterende stappen geautomatiseerd die eerder veel tijd kosten.” 

### Agile werken bespaart tijd 
Maar misschien wel de belangrijkste bijdrage van Diana was juist niet technisch. “Het hele ontwikkelproces was oorspronkelijk opgezet volgens de watervalmethode, als één groot geheel dus. Ik heb geprobeerd om dit stukje bij beetje om te zetten in een Agile benadering. Hierdoor ging het ontwikkelen een stuk sneller. Samen met de snelle ontwikkelingstijd die bij OutSystems hoort, zijn we erin geslaagd de applicatie veel sneller op te leveren dan gepland.”

*Heb jij ook een app die aan vervanging toe is, of een upgrade kan gebruiken? Wij denken graag met je mee over een passende oplossing. Neem contact op met één van onze experts voor meer informatie. Of lees onze [whitepaper](https://www.linkit.nl/cases/Hoe-Intratuin-weer-'groeit-en-bloeit'-met-OutSystems?whitepaper=open) over het vervangen van legacy applicaties met OutSystems.*

Foto: Marion Golsteijn

OS-intratuin.jpg

Manage an assortment of  10000+ products, supplying 50+ stores and handling millions of customers through one portal with native Android? You can in OutSystems!

Via één portal met native Android een assortiment van tienduizenden producten, in meer dan 50 winkels en voor miljoenen klanten managen? Dat kan met OutSystems!

Portal bouwen met OutSystems

Rebuilding a central application for inventory management

Het heropbouwen van een portaal voor voorraadbeheer

How Intratuin grows and flourishes again with OutSystems

Hoe Intratuin weer ‘groeit en bloeit’ met OutSystems

Low code projects we did

Low-code projecten die we eerder deden

outsystems.png

OutSystems

Leapwork_Logo_Primary_RGB.svg

Leapwork

itup.png

ITUp

mendix_62bf4701e9.png

Mendix

Low code

Low-code

rows-shelves-with-goods-boxes-modern-industry-warehouse-store-factory-warehouse-s-min-overlay.jpg

A cost-efficient and smart supply chain 

Kostenbesparing en slimmer op de plek van bestemming met IT

Logistics & Transport

Logistiek & Transport

abstract-blur-organic-fresh-fruits-vegetable-grocery-shelves-supermarket-store-defocused-bokeh-light-background-min.jpg

Changing traditional business models to stay relevant 

Traditionele bedrijfsmodellen op de schop om relevant te blijven

Retail

overheid.jpg

A partner with experience 

Een partner die bekend is met de structuur en processen binnen de (Rijks)overheid

Government

Overheid

order-to-cash-hero.jpg

Replacing legacy software by using low-code

Legacy vervangen met low-code

Order to cash automation

kelly-sikkema-v9FQR4tbIq8-unsplash.jpg

Customer-centric platforms driven by great UX and design

Klantgerichte platformen gedreven door UX en design

Customer portals & digital customer journey

Klantportalen & digitale customer journey

designthinking.jpg

Creating business value through design thinking

Toegevoegde waarde creëren met design thinking

Design thinking

Low code business themes and markets

Low-code uitdagingen en markten

Events

large_lowcode.jpg

medium_lowcode.jpg

small_lowcode.jpg

thumbnail_lowcode.jpg

lowcode.jpg

Low code animatievideo + subs EN.mp4

Deliver 50% faster results in application development compared with traditional development

Applicaties ontwikkelen in 50% van de tijd ten opzichte van traditionele methoden 

The leaders of modern application development and communication APIs are inviting you to join the 2020 OutSystems-Vonage-LINKIT Developer Challenge

Enter the OutSystems-Vonage-LINKIT Developer Challenge

Vonage

2020 OutSystems-Vonage-LINKIT Developer Challenge

The Age of Digital Transformation and Remote Communications Has Arrived

What you need to know

1. Developer Challenge: November 4 - November 13, 2020

2. The Prizes!

3. Kick-Off Webinar: November 4, 2020

Questions?

Contact Remco

Register for 2020 OutSystems-Vonage-LINKIT Developer Challenge