Je hebt al een Python-script dat een CSV-bestand opschoont, KPI's berekent en misschien zelfs een grafiek genereert. Het probleem doet zich meteen daarna voor. Hoe leg je dit voor aan degenen die beslissingen moeten nemen, maar nooit een terminal openen?
Hier bepaalt een GUI de waarde van je werk. Een knop ‘Gegevens laden’, een menu om de periode te kiezen, een overzichtelijke tabel en een grafiek die in realtime wordt bijgewerkt, maken van een technische analyse een praktisch hulpmiddel. In een Italiaanse context is dit van groot belang: Tkinter is sinds 1998 de standaardbibliotheek voor GUI-ontwikkeling in Python en in 2023 heeft 68% van de Italiaanse Python-ontwikkelaars op GitHub en Stack Overflow het gebruikt voor prototypes, gedreven door de vraag naar snelle analytische tools voor het MKB. Dankzij de eenvoud ervan kan de ontwikkelingstijd ook met 40-50% worden verkort in vergelijking met Java Swing (referentie).
Als je GUI met Python aan het leren bent, is het goede nieuws dat je niet meteen met een complexe app hoeft te beginnen. Het volstaat om een interface te bouwen die invoer, datalogica en duidelijke uitvoer met elkaar verbindt. Van daaruit kun je verdergaan naar meer uitgewerkte dashboards, pakketten voor het team en integraties met analyseplatforms.
Een terminalscript werkt prima als jij de gebruiker bent. Zodra de doelgroep bestaat uit een marketingmanager, een collega van de financiële afdeling of het management, is de terminal geen interface meer, maar een barrière.
De beslissers willen zich geen commandoregelopdrachten, bestandslocaties of Python-afhankelijkheden hoeven te herinneren. Ze willen een dataset kiezen, op ‘Analyseren’ klikken en een duidelijk resultaat te zien krijgen. Als je deze stap niet aanbiedt, is het risico niet alleen technisch. Het is ook organisatorisch. De analyse blijft dan voorbehouden aan degenen die kunnen programmeren.
Een goed ontworpen grafische gebruikersinterface vermindert weerstand op drie praktische punten:
Een goede interface maakt het model niet slimmer. Het zorgt ervoor dat de inzichten beter bruikbaar zijn.
Dit verandert de manier waarop je werk wordt gezien. Een script wordt vaak beschouwd als een persoonlijk hulpmiddel. Een desktopapplicatie, hoe klein ook, wordt daarentegen gezien als een bedrijfsmiddel. In een MKB-bedrijf is dat verschil belangrijk, want de waarde zit niet alleen in de juiste analyse, maar ook in het vermogen om deze continu te laten gebruiken.
Wanneer je een script omzet in een GUI, voeg je niet zomaar ‘vensters en knoppen’ toe. Je slaat een brug tussen gegevensverwerking en besluitvorming.
Denk eens aan veelvoorkomende gevallen:
Een script beantwoordt de vraag „werkt het?”.
Een GUI beantwoordt de vraag „zal iemand dit echt gebruiken?”.
Als je met Python aan een GUI werkt, moet je één ding goed onthouden: de interface is geen louter esthetische toevoeging. Het is de laag die je analyse toegankelijk, herhaalbaar en deelbaar maakt. Kortom, het zorgt ervoor dat de gegevens uit het notebook terechtkomen op het bureau van de besluitvormers.
Kies een framework niet op basis van trends. Kies het op basis van het soort app dat je moet opleveren, de tijd die je hebt en de mensen die de app dagelijks zullen gebruiken.
Voor veel interne projecten komt de keuze in feite neer op drie opties: Tkinter, PyQt en Kivy. Ze zijn niet allemaal hetzelfde. Ze hebben verschillende sterke punten, maar ook heel concrete nadelen.
Vraag jezelf, voordat je een beslissing neemt, het volgende af:
Wie gaat de app gebruiken?
Als de eindgebruiker een interne, niet-technische medewerker is, is gebruiksgemak belangrijker dan de elegantie van het framework.
Hoe groot zal het project '
' worden? Een KPI-calculator en een dashboard met meerdere panelen stellen niet dezelfde eisen.
Waar moet
draaien? Alleen op Windows-desktops? Ook op macOS? Is er een touch-vriendelijke gebruikersinterface nodig?
| Framework | Leercurve | Ideaal gebruiksscenario | Licentie |
|---|---|---|---|
| Tkinter | Laag | Interne tools, prototypes, lichte apps voor invoer en eenvoudige rapportages | Inbegrepen bij Python |
| PyQt | Media | Professionele dashboards, complexe desktoptoepassingen, visuele analyse | Controleer de licentievoorwaarden voordat u het product voor commerciële doeleinden gebruikt |
| Kivy | Media | Multiplatform-apps en touch-vriendelijke interfaces | Controleer de voorwaarden van het gekozen project en de afhankelijkheden |
Tkinter is de meest voor de hand liggende keuze als je snel aan de slag moet. Het zit in Python ingebouwd, biedt essentiële widgets en dwingt je om eerst na te denken over de gebruikersstroom in plaats van over de vormgeving.
Geschikt voor:
Het voordeel is praktisch: je kunt meteen aan de slag zonder een extra ecosysteem te hoeven installeren. De beperking wordt duidelijk wanneer de app visueel veel complexer wordt of uitgebreide interacties moet verwerken.
PyQt is een enorme sprong voorwaarts. Sinds 2005, met de introductie van PyQt en wxPython, is het aandeel van GUI-ontwikkeling met Python in de Italiaanse IT-sector gestegen tot 45% van alle desktopprojecten in 2024, en biedt PyQt 30% betere prestaties dan Tkinter bij complexe apps (gegevens afkomstig van Codefinity).
Voor een mkb-bedrijf komt dit neer op een eenvoudige vraag: moet de app eruitzien als een volwaardig softwareproduct? Als het antwoord ja is, is PyQt het overwegen waard.
Vuistregel: als je meerdere weergaven, filters, grafieken en bijgewerkte gegevens in één venster moet weergeven, is PyQt bijna altijd handiger dan Tkinter.
PyQt is geschikt voor:
Het vergt meer discipline. Lay-out, signalen, slots en verpakking zijn stappen die je goed moet begrijpen. Maar het eindresultaat lijkt meer op een commerciële toepassing.
Kivy komt in beeld wanneer de desktop niet volstaat. Als je een app voor ogen hebt die ook op tablets of touchscreens wordt gebruikt, hanteert Kivy een andere aanpak dan de andere twee frameworks.
Het is een verstandige keuze voor:
Het nadeel is dat het uiterlijk en het mentale model van de interface minder sterk op de traditionele desktop zijn gebaseerd dan bij PyQt. Als je je richt op een administratieve afdeling met Windows-pc's, is dit vaak niet de eerste keuze.
Gebruik deze snelkoppeling om een beslissing te nemen zonder je te verliezen in onbelangrijke details:
Het juiste framework is niet per se het krachtigste. Het is het framework dat de applicatie in de praktijk brengt zonder je onnodig te vertragen.
Maandagochtend. Het marketingteam moet binnen enkele minuten kunnen zien welke campagnes daadwerkelijk winst opleveren, maar de berekening van de ROI gebeurt nog steeds in een Excel-sheet die door verschillende mensen wordt aangepast. In dit soort gevallen is er geen complex platform nodig. Wat je nodig hebt, is een kleine, betrouwbare tool die twee getallen verzamelt, een duidelijke regel toepast en een consistent resultaat oplevert.
Tkinter is geschikt voor deze eerste stap. Hiermee kun je een Python-script omzetten in een interface die ook mensen die niet kunnen programmeren kunnen gebruiken zonder de terminal te hoeven openen. Voor een eerste dataproject is dit het echte voordeel: je haalt een berekening uit de notebook en maakt deze beschikbaar voor besluitvormers.
We maken een ROI-calculator met een eenvoudige opzet:
Dit is een realistisch gebruiksscenario. Een marketingmanager, een verkoper of een junior analist voert deze controle vaak uit om campagnes, promoties of kanalen te evalueren. Als de berekening handmatig blijft, bestaat het risico dat iedereen verschillende formules toepast. Een kleine grafische gebruikersinterface beperkt de kans op fouten en maakt het proces herhaalbaar.
import tkinter as tkfrom tkinter import ttk, messageboxdef calcola_roi():try:costo = float(entry_costo.get())ricavo = float(entry_ricavo.get())if costo <= 0:messagebox.showerror("Errore", "Il costo deve essere maggiore di zero.")returnroi = ((ricavo - costo) / costo) * 100risultato_var.set(f"ROI: {roi:.2f}%")except ValueError:messagebox.showerror("Errore", "Inserisci solo valori numerici validi.")root = tk.Tk()root.title("Calcolatore ROI")root.geometry("380x220")root.resizable(False, False)frame = ttk.Frame(root, padding=20)frame.pack(fill="both", expand=True)ttk.Label(frame, text="Costo marketing").grid(row=0, column=0, sticky="w", pady=5)entry_costo = ttk.Entry(frame, width=25)entry_costo.grid(row=0, column=1, pady=5)ttk.Label(frame, text="Ricavo generato").grid(row=1, column=0, sticky="w", pady=5)entry_ricavo = ttk.Entry(frame, width=25)entry_ricavo.grid(row=1, column=1, pady=5)ttk.Button(frame, text="Calcola ROI", command=calcola_roi).grid(row=2, column=0, columnspan=2, pady=15)risultato_var = tk.StringVar(value="ROI: in attesa")ttk.Label(frame, textvariable=risultato_var, font=("Arial", 12, "bold")).grid(row=3, column=0, columnspan=2, pady=10)root.mainloop()root = tk.Tk() start het hoofdvenster op. titel, meetkunde en aanpasbaar bepalen de gebruikscontext. Bij een interne tool is de duidelijkheid van de interface veel belangrijker dan het visuele effect.
Het blok met ttk.Frame, ttk.Label en ttk.Entry bouwt de module op. Ik heb veel beginnende Tkinter-toepassingen gezien die met basiswidgets begonnen en al snel rommelig werden. ttk helpt je er met weinig moeite netter uit te zien.
Het belangrijkste is calcola_roi(). Hier is de GUI niet langer alleen maar een venster, maar wordt het een gegevensapplicatie:
Validatie heeft betrekking op het eindproduct, niet alleen op de code. Als een collega tekst invoert in plaats van een getal of een bedrag van nul, is dat geen technisch probleem. Het probleem is dat die gegevens tot een verkeerde beslissing kunnen leiden.
Voor deze eerste app is het raadzaam om de scope beperkt te houden. Eén berekening. Eén scherm. Eén operationeel doel.
Deze methode voorkomt drie veelgemaakte fouten:
De test om te zien of het werkt, is simpel. Een afdelingshoofd moet de app kunnen openen, de campagnegegevens kunnen invoeren en binnen enkele seconden een betrouwbaar antwoord krijgen.
Zodra het daadwerkelijke gebruik is bevestigd, kun je de tool op een gestructureerde manier uitbreiden:
Als je grafieken wilt kiezen die bij deze resultaten passen, helpt de gids over grafiektypen die nuttig zijn om gegevens om te zetten in operationele beslissingen je om decoratieve grafieken te vermijden en te kiezen voor grafieken die het resultaat echt verduidelijken.
Een GUI-project met Python is zinvol wanneer het de kloof tussen analyse en besluitvorming verkleint. Tkinter legt dit eerste deel van het traject goed af. Het neemt een script dat in handen is van programmeurs en zet dit om in een tool die bruikbaar is voor marketing, operations of finance.
Vanaf daar is de volgende stap interessanter dan de knop zelf. Door invoer en logica te standaardiseren, zorg je voor schonere gegevens voor dashboards, rapporten en AI-inzichten. Op dat moment is een kleine GUI niet langer alleen een technische oefening, maar wordt het een brug naar een platform als ELECTE, waar diezelfde gegevens op een begrijpelijke manier aan het management kunnen worden gepresenteerd en gebruikt kunnen worden om betere beslissingen te nemen.
Als de gegevens niet meer op één scherm passen, begint Tkinter te haperen. Een dashboard met filters, tabellen, indicatoren en grafieken vereist een stevigere structuur. Hier is PyQt dan een logische keuze.
Een goed dashboard toont niet alles op het scherm. Het stuurt de aandacht. De filter moet zich bevinden waar de gebruiker die verwacht. De hoofdgrafiek moet veranderen wanneer de periode verandert. De KPI’s moeten leesbaar blijven zonder dat er onnodige subvensters worden geopend.
Een praktische indeling voor een verkoopdashboard ziet er als volgt uit:
Met PyQt is het eenvoudig om dit schema te bouwen dankzij lay-outs zoals QVBoxLayout, QHBoxLayout en QGridLayout.
Het onderstaande fragment toont een klein dashboard met een filter per kwartaal en een label dat wordt bijgewerkt wanneer de selectie verandert.
import sysfrom PyQt5.QtWidgets import (QApplication, QWidget, QVBoxLayout, QHBoxLayout,QLabel, QComboBox, QTableWidget, QTableWidgetItem)from PyQt5.QtCore import Qtclass DashboardVendite(QWidget):def __init__(self):super().__init__()self.setWindowTitle("Dashboard Vendite")self.resize(700, 450)layout_principale = QVBoxLayout()barra_filtri = QHBoxLayout()self.combo_trimestre = QComboBox()self.combo_trimestre.addItems(["Q1", "Q2", "Q3", "Q4"])self.combo_trimestre.currentTextChanged.connect(self.aggiorna_dashboard)barra_filtri.addWidget(QLabel("Trimestre"))barra_filtri.addWidget(self.combo_trimestre)barra_filtri.addStretch()self.label_kpi = QLabel("Fatturato selezionato: dati Q1")self.label_kpi.setAlignment(Qt.AlignLeft)self.tabella = QTableWidget(3, 2)self.tabella.setHorizontalHeaderLabels(["Prodotto", "Vendite"])self.popola_tabella("Q1")layout_principale.addLayout(barra_filtri)layout_principale.addWidget(self.label_kpi)layout_principale.addWidget(self.tabella)self.setLayout(layout_principale)def aggiorna_dashboard(self, trimestre):self.label_kpi.setText(f"Fatturato selezionato: dati {trimestre}")self.popola_tabella(trimestre)def popola_tabella(self, trimestre):dati = {"Q1": [("A", "120"), ("B", "95"), ("C", "110")],"Q2": [("A", "140"), ("B", "88"), ("C", "130")],"Q3": [("A", "150"), ("B", "100"), ("C", "125")],"Q4": [("A", "170"), ("B", "115"), ("C", "160")]}righe = dati[trimestre]for riga, (prodotto, vendite) in enumerate(righe):self.tabella.setItem(riga, 0, QTableWidgetItem(prodotto))self.tabella.setItem(riga, 1, QTableWidgetItem(vendite))app = QApplication(sys.argv)finestra = DashboardVendite()finestra.show()sys.exit(app.exec_())Het sleutelbegrip hier is het verband tussen gebeurtenis en update. currentTextChanged.connect(self.dashboard_bijwerken) zorgt ervoor dat de interface direct reageert op een actie van de gebruiker. Dit is een van de redenen waarom PyQt zo geschikt is voor dashboards.
In echte apps volgt er na de tabel en de KPI’s meestal een Matplotlib-grafiek die in de lay-out is geïntegreerd. De logica is simpel:
De interface hoeft niet alles te berekenen. Ze moet de onderdelen op elkaar afstemmen en het resultaat op de juiste manier presenteren.
In een goed dashboard heeft elke filter een voorspelbaar effect. Als de gebruiker een selectie wijzigt en niet begrijpt wat er is bijgewerkt, schiet de gebruikersinterface al tekort.
Voor een breder beeld van hoe je analytische dashboards kunt opzetten, is het nuttig om deze aanpak te vergelijken met de handleiding van ELECTE het maken van analytische dashboards op ELECTE.
PyQt vereist meer voorbereiding dan Tkinter, maar biedt je in ruil daarvoor meer overzicht wanneer het project groeit. Het is met name de moeite waard als je:
Als je een dashboard wilt dat het management elke ochtend zonder technische ondersteuning kan openen, is PyQt vaak de meest betrouwbare keuze.
Een GUI die alleen in je ontwikkelomgeving werkt, is nog niet klaar voor gebruik. De echte problemen beginnen pas als je hem met onzuivere gegevens test, hem aan een collega doorgeeft of hem opent op een laptop die ouder is dan die van jou.
Er zijn drie categorieën die steeds weer terugkomen:
Een numeriek veld krijgt tekst binnen. Een CSV-bestand heeft verschillende kopteksten. Een datum wordt in een onverwacht formaat aangeleverd.
De oplossing is om vroeg te valideren en begrijpelijke foutmeldingen weer te geven, in plaats van tracebacks.
Dit gebeurt wanneer je tijdrovende bewerkingen uitvoert in de hoofdthread. Het laden van grote bestanden, het opvragen van API’s of het berekenen van complexe modellen kan ervoor zorgen dat het venster vastloopt.
Om dit te voorkomen:
De knop 'Analyseren' blijft actief, ook als er geen bestand is geüpload. Het filter verandert, maar de grafiek niet.
Hier is discipline nodig: elke handeling van de gebruiker moet alleen datgene bijwerken wat daarmee verband houdt en de app in een consistente toestand achterlaten.
Verpakken betekent dat je het project omzet in iets dat een collega kan openen zonder handmatig bibliotheken te hoeven installeren. Met PyInstaller verloopt het basisproces heel eenvoudig:
Voor veel apps volstaat een 'one file'- of 'one folder'-build. De keuze hangt af van de grootte, de opstarttijd en de aanwezigheid van externe bestanden, zoals pictogrammen of configuratiebestanden.
Een handige tip: maak voor de build een overzichtelijke projectmap aan. Als je scripts, testdatasets, afbeeldingen en tijdelijke bestanden door elkaar gooit, wordt de packaging al snel kwetsbaar.
Dit is een aspect dat bij kleine en middelgrote ondernemingen vaak over het hoofd wordt gezien. 55% van de Italiaanse bedrijven maakt gebruik van goedkope hardware, en uit praktijktests blijkt dat niet-geoptimaliseerde frameworks zoals Tkinter bij complexe apps tot wel 40% trager kunnen zijn, terwijl lichtere oplossingen tot wel twee keer zo snel kunnen zijn (zie het uitgebreide artikel van ActiveState).
Het knelpunt ligt niet altijd bij het framework. Vaak gaat het om de manier waarop je gegevens laadt, widgets bijwerkt en de hoofdthread beheert.
Een responsieve gebruikersinterface vergroot het vertrouwen van de gebruiker. Een trage gebruikersinterface wordt links laten liggen, zelfs als de onderliggende analyse klopt.
Op een gegeven moment moet de GUI zich niet langer beperken tot het weergeven van lokale formules. Ze moet de front-end worden van een uitgebreidere analytische engine. Op dat moment krijgt het project een heel andere dimensie.
In Italië klaagt 68% van de kleine en middelgrote ondernemingen in de IT-sector over een gebrek aan gebruiksvriendelijke tools om AI-inzichten te visualiseren, en veel tutorials blijven steken bij de basisframeworks, waardoor een potentieel van 45% voor op maat gemaakte Python-GUI’s op het gebied van analytics onbenut blijft (bron). Dit cijfer maakt het punt duidelijk: het gaat niet alleen om het genereren van inzichten. Het gaat erom ze toegankelijk te maken.
Eenvoudige berekeningen, invoervalidatie en lokale filters werken prima in desktop-apps. Prognoses, risicoscores, segmentaties of uitgebreidere rapportages kunnen vaak beter op een extern platform worden uitgevoerd.
Een Python-GUI kan dus een lichte client worden die:
Bij deze aanpak worden de rollen gescheiden. De interface zorgt voor de gebruikerservaring. De analyse-engine zorgt voor de verwerking.
Het onderstaande voorbeeld is bewust conceptueel. Het toont het typische patroon met verzoeken.
import requestsdef ottieni_insight(dati_input):url_api = "https://api.electe.example/insights"payload = {"dataset": dati_input,"analisi": "forecast_vendite"}response = requests.post(url_api, json=payload, timeout=30)response.raise_for_status()return response.json()Een mogelijk antwoord zou er ongeveer zo uit kunnen zien:
{"forecast": [{"mese": "Gennaio", "valore_previsto": 1250},{"mese": "Febbraio", "valore_previsto": 1320}],"alert": ["Rischio stock-out su categoria A"],"summary": "Trend positivo nel prossimo periodo"}In de GUI kun je deze blokken selecteren en ze aan verschillende elementen toewijzen:
samenvatting in een tekstkaart;waarschuwing in een gemarkeerde lijst;prognose in een tabel of grafiek.Voor wie al met het product werkt: de technische basis wordt beschreven in de API's van ELECTE een geverifieerd Postman-profiel.
Hier schieten veel projecten tekort. Ze ontvangen weliswaar correcte JSON-gegevens, maar geven die zonder hiërarchie weer op het scherm.
Een structuur met drie niveaus werkt het beste:
Belangrijkste boodschap
Een korte samenvatting die meteen duidelijk maakt wat er aan de hand is.
Operationele inzichten
-waarschuwingen, afwijkingen, kritieke producten, prioritaire segmenten.
Verkenbare details
: tabellen, grafieken, export, uitvoeringsgeschiedenis.
Een effectieve gebruikersinterface toont niet alles tegelijk. Eerst wordt getoond wat helpt bij het nemen van een beslissing, daarna wat nodig is om te controleren.
Met dit model is GUI met Python niet langer een technische oefening. Het wordt een werkinterface die gegevens, automatisering en inzichten met elkaar verbindt, die ook voor niet-gespecialiseerde teams begrijpelijk zijn.
Als je je eerste app aan het bouwen bent, kies dan voor Tkinter. Hiermee krijg je inzicht in gebeurtenissen, widgets, validatie en de structuur van de interface zonder al te veel afhankelijkheden.
Als je nu al weet dat het project moet uitgroeien tot een uitgebreider dashboard, kun je het beste met PyQt beginnen. Dit vraagt wel wat meer aandacht voor de architectuur, maar voorkomt dat je later, als de app groeit, dingen opnieuw moet schrijven.
Dat hangt af van de gebruikscontext. Als de belangrijkste vereiste platformonafhankelijkheid met touchbediening is, is Kivy een logische keuze. Als de app daarentegen vooral op desktops wordt gebruikt door administratieve, commerciële of financiële teams, zijn Tkinter of PyQt vaak een logischere keuze.
Een desktop-GUI is handig wanneer je:
Een webapp is het meest geschikt wanneer de toegang op afstand, gecentraliseerd en via een browser moet plaatsvinden. De juiste keuze hangt minder af van de technologie en meer van wie de app gaat gebruiken, waar en met welke IT-beperkingen.
Het praktische advies luidt: controleer altijd de licentie voordat je het programma commercieel gebruikt. Bij een persoonlijk of klein intern project wordt dit punt vaak te snel over het hoofd gezien. Binnen een bedrijf moet dit daarentegen vanaf het begin worden afgestemd met de persoon die verantwoordelijk is voor inkoop of softwarecompliance.
Voer geen tijdrovende bewerkingen uit in de hoofdthread van de gebruikersinterface. Grote bestanden, API-aanroepen en analysemodellen moeten worden verplaatst naar aparte threads of processen, of worden gecoördineerd met wachtrijen en callbacks voor updates.
Drie regels helpen enorm:
Bewaar bij gevoelige gegevens geen inloggegevens in de code en laat geen tijdelijke bestanden achter in gedeelde mappen. Als de app gegevens naar externe diensten verstuurt, geef dan altijd duidelijk aan welke informatie wordt verzonden en op basis van welke toestemmingen.
Dit is met name van belang op het gebied van financiën, compliance en bij het omgaan met klantgegevens. Neem bij twijfels over de regelgeving contact op met de functionaris voor gegevensbescherming of de juridische afdeling. Dit artikel vormt geen juridisch of compliance-advies.
Ja. Dat is een veelvoorkomende combinatie in analytische desktoptools. De uitdaging ligt niet zozeer in het weergeven van de grafiek, maar wel in het goed synchroniseren ervan met filters, tabellen en de status van de applicatie.
Te veel bouwen, te vroeg. Een eerste applicatie moet een paar dingen betrouwbaar kunnen doen: gegevens laden, invoer controleren, een analyse starten en duidelijke resultaten weergeven.
Pas als deze basis goed werkt, kun je exportfuncties, grafieken, een historisch overzicht, authenticatie of externe integraties toevoegen. Daarvoor niet.
Als je je tools verder wilt ontwikkelen dan het prototype en een Python-GUI wilt koppelen aan daadwerkelijk bruikbare inzichten, ELECTE helpt je om ruwe data om te zetten in rapporten, voorspellingen en analyses die voor het hele team begrijpelijk zijn. Het is een concrete manier om de overstap te maken van losstaande scripts naar AI-ondersteunde besluitvorming. Je kunt zien hoe het werkt en beoordelen of het bij jouw workflow past.
.svg)
.svg)
.svg)
