De echte kost van rommelige timesheets

Timesheets zijn zelden het probleem, wel het effect

Timesheets hebben een vreemde status in veel consultancy- en projectorganisaties. Iedereen weet dat ze belangrijk zijn, maar niemand wordt er echt enthousiast van. Ze hangen ergens tussen ​“administratie” en ​“noodzakelijk kwaad”, en net daardoor krijgen ze vaak niet de aandacht die ze verdienen.

Toch is de impact groot.

Niet omdat een timesheet op zich zo’n strategisch instrument is, maar omdat het de plek is waar verschillende zaken samenkomen:

• Planning
• Projectbudgetten
• Marge
• Facturatie

Zodra urenregistratie rommelig wordt, merk je dat zelden meteen. Het komt pas boven water wanneer finance gaat afsluiten, wanneer een projectmanager plots zijn forecast niet meer vertrouwt, of wanneer een klant vragen stelt bij een factuur. En tegen dat moment is het meestal te laat om het nog ​“makkelijk” op te lossen.

Het patroon dat iedereen herkent

Wat je dan ziet gebeuren, is bijna altijd hetzelfde.

Consultants proberen zich te herinneren wat er precies gedaan is. Projectcodes worden nagekeken. Er komen correcties. Er gaat wat heen-en-weer via mail of chat. En iemand bij finance zit alsnog manueel te puzzelen.

Dat is niemand zijn favoriete job. En belangrijker: het kost tijd die je eigenlijk niet wil spenderen aan herstelwerk.

Het wrange is dat dit meestal geen kwestie is van onwil of slordigheid. Het is hoe mensen werken. Je bent bezig met delivery, meetings, klantvragen, een sprint die doorschuift, een last-minute issue — en plots is het vrijdag.

Dan moet de timesheet nog.

Liefst snel. Liefst zonder er te lang over na te denken.

Dat maakt het menselijk.
Maar het maakt het systeem ook kwetsbaar.

Een andere vraag stellen

Tijdens onze AI Huddle vertrokken we daarom niet van:

“Hoe krijgen we iedereen braaf op tijd?”

Maar van een eerlijkere vraag:

Hoe maken we dit proces minder fragiel zonder extra administratieve druk te creëren?

Want als je alleen maar harder duwt op discipline, krijg je vaak hetzelfde resultaat. Alleen met meer frustratie.

Zo ontstond TimeGuard, onze hackathoncase rond AI-gedreven timesheet monitoring.

Niet als nieuw platform.
Niet als controletool.

Maar als een assistent die sneller ziet waar het misloopt en net op tijd kan bijsturen. Niet aan het einde van de maand wanneer alles brandt, maar onderweg — wanneer je nog iets kan fixen zonder drama.

Waarom dit meer is dan een administratief vraagstuk

Wie timesheets louter ziet als een administratieve verplichting, mist het bredere plaatje. Urenregistratie zit op een kruispunt van belangen. Niet alleen van finance, maar van het hele bedrijf.

Het raakt tegelijk aan:

• Finance, dat correcte en tijdige facturatie nodig heeft
• Projectmanagers, die willen sturen op marge en voortgang
• Consultants, die vooral goed werk willen leveren
• Management, dat beslissingen baseert op betrouwbare cijfers

Wanneer registratie achterloopt of onnauwkeurig gebeurt, begint het systeem te rammelen.

Forecasts worden minder betrouwbaar. Projectmarges lijken stabiel, tot ze plots niet meer kloppen. Facturatie schuift op, wat op zijn beurt impact heeft op cashflow. Dat zijn geen kleine operationele haperingen, maar signalen dat er iets structureels wringt.

Controle lost het zelden op

In veel organisaties wordt dat opgelost met extra controle.

Meer reminders.
Strakkere deadlines.
Soms zelfs manuele steekproeven.

Dat helpt tijdelijk. Maar het verandert weinig aan de kern van het probleem: het systeem reageert pas wanneer het al fout is gelopen.

En dan zit je opnieuw in herstelmodus.

Wat ontbreekt: realtime zicht op gedrag

Wat ons tijdens de voorbereiding van de Hackathon vooral opviel, is hoe weinig realtime inzicht er vaak is in registratiegedrag.

Je ziet wat er ingevuld is, maar niet wat er ontbreekt.
Je merkt een overschrijding wanneer het budget al geraakt is, niet wanneer het begint te verschuiven.
Je voelt dat er iets niet klopt, maar je kan het moeilijk objectiveren.

Dat maakt constructieve gesprekken lastig.

Zonder duidelijke signalen wordt feedback snel persoonlijk.
​“Je vult te laat in” klinkt anders dan:
​“We merken dat er deze week twee dagen ontbreken in je registratie.”

Het eerste is een oordeel.
Het tweede een observatie.

Dat verschil is subtiel, maar belangrijk.

De rol van AI in dit verhaal

Daar zagen we een rol voor AI. Niet om mensen te controleren, maar om patronen sneller zichtbaar te maken.

AI is sterk in het herkennen van afwijkingen:

• Wanneer iets plots anders loopt dan normaal
• Wanneer een trend zich begint af te tekenen
• Wanneer een kleine inconsistentie systematisch wordt

Bij TimeGuard hebben we dat vertaald naar een assistent die bovenop bestaande systemen kan meedenken. Geen vervanging van ERP of timesheetsoftware, maar een laag die kijkt naar gedrag en context.

Een systeem dat bijvoorbeeld kan signaleren dat een project deze maand opvallend meer uren bevat dan verwacht. Of dat een consultant structureel zijn registratie uitstelt tot het einde van de week.

Die signalen zijn op zich niet spectaculair. Maar ze geven teams de kans om vroeger bij te sturen.

En dat is het verschil tussen brandjes blussen en rustig corrigeren.

Wat voor ons belangrijk was: dit mocht geen AI-showcase worden. De technologie is interessant, maar het echte verhaal zit in wat ze mogelijk maakt — meer transparantie, minder frictie en een beter gesprek tussen teams.

Wat TimeGuard concreet doet (en vooral: wat het niet wil zijn)

Toen we TimeGuard begonnen uit te werken, hebben we één keuze heel bewust gemaakt: het mocht geen nieuw systeem worden.

De wereld zit al vol tools, dashboards en platformen die beloven dat alles beter wordt als je nog één extra laag toevoegt. Nog een login. Nog een interface. Nog een proces.

Dat wilden we net vermijden.

TimeGuard moest iets anders zijn. Geen vervanging van bestaande software, maar een intelligente monitoringslaag die bovenop wat er al is meedenkt.

De kern in drie bewegingen

In essentie doet TimeGuard drie dingen:

• Het kijkt naar registratiegedrag
• Het detecteert afwijkingen
• Het geeft gerichte feedback op het juiste moment

Dat klinkt eenvoudig, maar de kracht zit in de nuance.

Stel dat een consultant normaal dagelijks registreert, maar plots drie dagen niets invult. Of dat een project maand na maand netjes binnen budget blijft, maar deze maand ineens een opvallende piek vertoont.

In veel organisaties worden dat soort signalen pas zichtbaar tijdens closing. Tegen dan moet er gecorrigeerd worden, vaak onder tijdsdruk.

TimeGuard verschuift dat moment naar voren.

Het systeem kan bijvoorbeeld signaleren:

• Dat er ingeplande werkdagen zijn zonder registratie
• Dat een project significant afwijkt van het historisch patroon
• Dat een bepaalde fase systematisch meer uren genereert dan voorzien

Niet als alarm. Maar als observatie.

Assistent in plaats van controleur

De toon is daarin cruciaal.

We wilden vermijden dat het aanvoelt als controle. Daarom vertrokken we van het idee van een assistent in plaats van een controleur.

Een korte melding die zegt:

“We merken dat hier mogelijk iets ontbreekt. Klopt dit?”

In plaats van:

“Je hebt iets fout gedaan.”

Dat verschil bepaalt of mensen het systeem ervaren als ondersteuning of als micromanagement.

AI kan veel detecteren. Maar hoe je die detectie vertaalt naar interactie, bepaalt de adoptie.

Van individueel signaal naar organisatieniveau

Naast individuele signalen biedt TimeGuard ook inzicht op team- en organisatieniveau.

Niet om mensen te vergelijken. Wel om patronen te zien.

• Welke projecten kennen vaker correcties?
• Zijn er fases in een traject waar registratie systematisch achterloopt?
• Zijn er teams waar closing structureel meer druk veroorzaakt?

Dat soort inzichten zijn geen doel op zich. Ze vormen input voor betere afspraken, helderdere processen en realistischere planning.

Wat we tijdens de Hackathon merkten, is dat het gesprek snel verschoof van technologie naar governance.

Niet: ​“Hoe slim is het model?”
Maar: ​“Wat doen we met deze signalen?”
En: ​“Wie neemt hier ownership op?”

Precies daar wordt het interessant.

AI kan veel detecteren. Maar ze kan geen beslissingen nemen over cultuur. Dat blijft mensenwerk.

TimeGuard werd zo minder een technisch experiment en meer een spiegel. Het liet zien waar het systeem al sterk was — en waar het vooral leunde op gewoonte en goodwill.

Van idee naar systeem – wat Figma Make zichtbaar maakte

Tijdens de AI Huddle wilden we niet alleen praten over TimeGuard. We wilden tonen hoe je zo’n idee snel en doordacht kan vertalen naar een interface die meer is dan een mooi scherm.

Daar gebruikten we Figma Make voor.

Niet omdat het ​“de nieuwste tool” is. Wel omdat het toelaat om in korte tijd van concept naar een werkende structuur te gaan. En net die snelheid maakt iets interessants zichtbaar: of je denkt in losse schermen, of in een samenhangend systeem.

Niet starten met pixels, maar met structuur

We begonnen niet met kleuren of iconen.

We startten met een aantal fundamentele vragen:

• Welke informatie moet zichtbaar zijn?
• Welke signalen vragen aandacht?
• Wanneer wordt iets een waarschuwing en wanneer blijft het ondersteunend?
• Hoe voorkomen we dat het dashboard zelf een nieuwe bron van ruis wordt?

In plaats van scherm per scherm te ontwerpen, dachten we meteen in componenten.

Een overzicht met projecten en hun status.
Een detailweergave met signalen en context.
Badges die aangeven of iets in orde is of extra aandacht vraagt.
Feedbackcomponenten voor reminders en validatie.

Door die structuur eerst scherp te zetten, werd het visuele pas de tweede stap.

Snelheid als stresstest

Figma Make liet ons toe om die structuur snel neer te zetten en meteen te testen hoe ze zich gedroeg.

Wat gebeurt er als een project meerdere signalen krijgt?
Hoe ziet een waarschuwing eruit naast een succesmelding?
Wanneer wordt iets visueel dominant, en wanneer blijft het ondersteunend?

Die snelheid had een onverwacht effect.

De discussie ging niet over esthetiek, maar over schaalbaarheid.

“Blijft dit consistent als we hier tien extra use cases aan toevoegen?”
​“Is dit een herbruikbare component of een eenmalige oplossing?”

Dat soort vragen kwamen vanzelf naar boven.

En dat is precies wat we wilden uitlokken.

Versneller én spiegel

Figma Make werkte in deze context als een versneller én een spiegel.

Het versnelde het bouwen. Maar het maakte ook duidelijk waar we expliciet keuzes moesten maken.

Spacing werd geen visuele voorkeur meer, maar een afspraak.
States — error, warning, success — werden geen detail, maar een essentieel onderdeel van de ervaring.
Componenten moesten logisch uitbreidbaar zijn.

Wat we daar zagen, is iets wat we vaker tegenkomen in projecten.

Zolang je traag bouwt, kan je inconsistenties nog verbergen. Zodra het tempo omhooggaat, vallen ze sneller op. Dan wordt duidelijk of je design system stevig genoeg is om groei te dragen.

TimeGuard was in die zin niet alleen een AI-case, maar ook een test van onze eigen discipline.

Denken we echt in systemen?
Of vervallen we toch in schermdenken zodra het snel moet gaan?

Wat AI uiteindelijk blootlegt over volwassenheid

Wat deze hackathoncase voor ons zo interessant maakte, is hoe snel het gesprek verschoof.

In het begin ging het over monitoring. Over detectie. Over hoe slim een model kan zijn in het herkennen van afwijkingen. Maar naarmate we TimeGuard verder uitwerkten en via Figma Make tot een systemische UX kwamen, werd iets anders duidelijk.

AI versnelt.
En versnelling legt structuur bloot.

Wanneer je snel bouwt, wordt zichtbaar of je design system meer is dan een verzameling componenten. Of spacing echt vastligt, of het per scherm opnieuw wordt beslist. Of states doordacht zijn, of enkel bestaan voor de ​“happy flow”. Of accessibility een standaard is, of een vinkje op het einde van het traject.

De vraag die bleef hangen

Tijdens de sessie kwam er een vraag op tafel die langer bleef hangen dan verwacht:

Wie is eigenaar van gedrag?

Design bepaalt hoe iets eruitziet.
Development bepaalt hoe iets technisch werkt.

Maar wie bewaakt hoe een melding aanvoelt? Wie beslist wanneer een waarschuwing verschijnt? Wie zorgt ervoor dat feedback consistent is over verschillende schermen heen?

Zolang dat impliciet blijft, loopt het vaak goed genoeg. Tot het systeem groeit.

Dan ontstaan verschillen. Kleine afwijkingen. Net andere error-teksten. Iets andere timing in validatie. En voor je het weet, voelt een product minder coherent aan dan het ooit bedoeld was.

TimeGuard maakte dat tastbaar. Niet omdat het zo complex was, maar omdat het net eenvoudig begon. Een dashboard. Een paar signalen. Wat feedback. En toch doken meteen vragen op over governance, ownership en consistentie.

Dat is geen zwakte. Integendeel. Het is een teken dat het systeem serieus wordt genomen.

AI als spiegel, geen wondermiddel

Wat we meenemen uit deze Hackathon, is dat AI geen wonderoplossing is. Het is een laag die bestaande processen scherper maakt.

Als je processen rommelig zijn, zal AI dat niet verbergen.
Als afspraken vaag zijn, zal versnelling dat niet oplossen.
Als ownership onduidelijk is, zal technologie dat niet automatisch rechtzetten.

Maar als je bereid bent om systemisch te denken, om ownership expliciet te maken en om gedrag even belangrijk te vinden als vorm, dan kan AI een krachtige versterker zijn.

TimeGuard begon als een experiment rond timesheet monitoring. Het eindigde als een reflectie over hoe volwassen je organisatie is in het omgaan met technologie.

En misschien is dat wel de belangrijkste les.

Niet dat AI sneller is.
Maar dat ze vraagt om helderdere systemen.