DIGIBPM — SmartInvoice
From paper & email workflows → automated timesheet processing and invoice generation.
Process Digitalization • BPMN/DMN Modeling • Workflow Automation
Overview
SmartInvoice is a process digitalization project where we re-designed a manual timesheet and invoicing workflow into a structured, traceable, and automation-ready system. The solution is organized into two pillars — Timesheet Management and Invoice Generation — with clear validation, decision logic, and exception routing.
The problem (AS-IS)
Manual validation & rework
Timesheets and invoices required repetitive checking, re-entry, and manual coordination — increasing delays and the chance of errors.
Email-driven workflow
Email acted as the main trigger and control mechanism, which limited transparency, made follow-ups harder, and increased operational bottlenecks.
Low scalability & weak exception handling
When information was missing or inconsistent, the process often stalled without a structured way to route issues and resolve them.
My contribution
I focused on translating a real, messy operational workflow into a structured digital process. My main contribution was helping design and refine the TO-BE logic so the solution didn’t just automate tasks — it created clarity through decision points, traceability, and exception handling. I also contributed to aligning the end-to-end flow between timesheet creation, validation, billability decisions, and invoice generation so that outputs remain consistent and usable for HR and Accounts.
What I worked on
TO-BE logic, routing, validation points, end-to-end consistency
How I approached it
Model first → validate assumptions → then automate
Why it mattered
Clear ownership, auditability, and reliable exception paths
The solution (TO-BE)
Pillar 1 — Timesheet Management
A structured lifecycle for timesheets: standardized creation from templates, monthly batch processing, validation, and billability decisions via DMN — with routing into processed/error paths for traceability.
- Template-driven creation
- Monthly batch processing
- DMN decision logic (billable vs non-billable)
- Processed vs error routing + notifications
Pillar 2 — Invoice Generation
A dedicated invoice process with templated records, validation and review, structured storage, and a controlled send/update flow — again with exception handling through error routing.
- Template-based invoice records
- Review + validation before sending
- Structured storage for auditability
- Error routing for fast correction
How it works (high level)
Timesheet flow
- 1Employee initiates a timesheet request (user task) and submits required information.
- 2A standardized timesheet is created from a template (automated creation).
- 3Monthly batch processing loads all submitted timesheets (automation flow).
- 4Project/customer details are fetched and linked for validation.
- 5Decision logic determines billable vs non-billable entries (DMN rule).
- 6Allocation/consistency checks run and outcomes are generated.
- 7Outputs are routed into processed vs error folders with notifications for follow-up.
Invoice flow
- 1Invoice record is created from a template to ensure consistency.
- 2Invoice is stored and tracked in a structured location for traceability.
- 3Accounts team receives a notification / task for review.
- 4Validation routes invoices/timesheets into processed vs error paths as needed.
- 5Invoices are loaded for periodic review and completion.
- 6Bank transfer prep + sending to client (finalization step).
- 7Records are updated and the invoice is moved to the processed folder.
Artifacts
Replace the placeholders below with screenshots of your BPMN/DMN models, Make scenarios, and folder routing. Put images in /public/images/projects/digibpm/ and update the paths in this file.
BPMN — AS-IS overview
Initial workflow mapping to capture the current manual process and bottlenecks.
BPMN — TO-BE (Timesheet Management)
Redesigned end-to-end flow for standardized creation, validation, and monthly batch processing.
BPMN — TO-BE (Invoice Generation)
Structured invoice lifecycle with validation, review, routing, and record updates.
DMN — Billability decision table
Business rules captured as decisions (e.g., billable vs non-billable) to keep logic explicit and maintainable.
Automation — Make scenarios & webhooks
Integration view showing how triggers, batch runs, and data movement connect systems end-to-end.
Storage & routing — Processed vs Error
Folder structure demonstrating traceability and exception handling throughout the workflow.
What I learned
BPMN as a thinking tool
Modeling AS-IS and TO-BE helped turn a messy, real workflow into clear responsibilities, handovers, and control points.
DMN for decision clarity
Separating decision logic (billable vs non-billable) from the process flow made rules easier to maintain and explain.
Automation needs exception paths
A reliable system isn’t only the happy path — folder routing + notifications made errors visible and fixable.
Traceability by design
Consistent storage and routing (processed/error) improves auditing, accountability, and follow-up speed.
Integration mindset
Combining Camunda orchestration with Make + webhooks showed how to connect tools into one dependable workflow.
If I had to summarize the takeaway: process digitalization works best when it combines clear modeling, explicit decisions, and real exception handling — not just automation.
Want to see more?
I can share artifacts and a short walkthrough upon request.