Some projects start with a ticket.
This one started with a phone call.
A good friend of mine — the CEO of Telaga Group of Companies — reached out and said something along the lines of:
“Bro, our assets are everywhere. Spreadsheets here, WhatsApp there, maintenance notes somewhere else. We need one system. Can you fix this chaos?”
Now if you know me, you already know the answer was yes before he finished the sentence.
I’ve worked with them before on their reservation platform for Telaga Seafood, so I already understood their workflow style, operational pain points, and — most importantly — where systems usually fail in real businesses: not in features, but in usability.
This wasn’t going to be another pretty dashboard nobody uses.
This had to be operational software.
The Real Problem Most Companies Have (But Don’t Talk About)
On paper, asset management sounds simple:
-
Track items
-
Assign owners
-
Maintain them
-
Audit occasionally
In reality, it looks more like:
-
Nobody knows who has what
-
Maintenance only happens when something breaks
-
Transfers are verbal
-
Audits are panic-driven
-
Finance reports are… creative
The core issue is fragmentation. Systems exist, but they don’t talk to each other — or worse, they’re spreadsheets pretending to be systems.
That’s exactly the gap this project aimed to fix.
The Goal Was Never “Build a System”
The goal was:
Build something people actually use daily.
So instead of thinking like a developer, I designed it like an operations manager.
That meant:
-
strict access boundaries
-
real workflow approvals
-
audit trails
-
mobile-first interaction
-
QR-based physical tracking
Not a CRUD app. A working platform.
What the System Actually Does
At its core, the platform manages the full asset lifecycle inside one controlled environment:
-
asset onboarding and tagging
-
assignment and transfer workflows
-
maintenance work orders
-
stocktake sessions
-
disposal governance
-
reporting + audit logs
All of that is confirmed in the system’s feature spec.
Everything is role-driven so users only see what they should see.
The Role Design Was Intentional
One thing I’ve learned from building internal systems:
Permissions matter more than features.
So the platform runs on four roles:
-
Superadmin
-
Admin
-
Manager
-
Staff
Each role has real-world boundaries.
For example:
-
Staff can perform tasks but can’t access sensitive modules.
-
Managers can approve transfers and disposals.
-
Only higher roles can activate stocktake sessions.
This isn’t theoretical — it’s enforced at policy level, not just UI hiding.
That distinction alone prevents most internal misuse and accidental data damage.
Dashboards That Actually Help People Work
Different roles see different dashboards:
-
Staff → their tasks and scans
-
Managers → team workload + progress
-
Admin → system-wide alerts
-
Superadmin → organization metrics
So instead of one overloaded screen, everyone sees what matters to them.
That’s not just UX.
That’s operational clarity.
QR-Driven Workflow (The Real Game Changer)
If you want people to use a system, remove friction.
So I made scanning the main interaction.
Scan → open asset → take action.
From that screen, users can:
-
report issues
-
update maintenance
-
verify during stocktake
No searching. No typing asset IDs. No confusion.
The system even generates printable tag sheets with QR codes for physical labeling.
Because software shouldn’t live only inside screens. It should match the real world.
Maintenance Tracking That Doesn’t Wait for Breakdowns
Most companies don’t do preventive maintenance.
They do reactive maintenance.
So I built work orders with:
-
priorities
-
assignments
-
deadlines
-
evidence uploads
-
progress states
Staff can update only the work orders assigned to them, and once closed, they’re locked from edits.
Translation: no retroactive “editing history” to cover mistakes.
Stocktake Mode (My Favorite Feature)
Audits are usually a nightmare.
So I turned stocktaking into a controlled session system:
-
create session
-
assign staff
-
activate
-
scan assets
-
reconcile results
The system automatically calculates:
-
expected
-
verified
-
missing
-
unexpected
And yes, discrepancies can be exported instantly.
What used to take days can now be done in hours.
Disposal Isn’t Just “Delete Asset”
In real organizations, disposal requires accountability.
So the system enforces a lifecycle:
requested → approved → executed
Each disposal record stores:
-
method (sale/scrap/lost/etc.)
-
sanitization notes
-
evidence files
Only when execution happens does the asset officially become disposed.
That makes audits painless.
Finance Layer (Because Management Always Asks)
Leadership doesn’t just want lists.
They want numbers.
So reporting includes:
-
depreciation calculations
-
maintenance cost totals
-
book value
-
open maintenance counts
Exportable CSVs are available for finance workflows.
Which means no more manual compilation before meetings.
Security Decisions I Took Seriously
Internal systems are often the weakest security link.
So I locked this down intentionally:
-
login-only entry point
-
public registration disabled
-
optional reCAPTCHA protection
-
strict role policies
-
activity logging
All access is scoped by organization, site, and department boundaries.
All known XSS, SQLi, and common vulnerability vectors have been patched and tested.
Under the Hood
The architecture foundation includes:
-
API-ready backend
-
authentication layer ready for expansion
-
idempotent request handling
-
Docker development stack
These technical foundations are documented in the system notes.
In short: built for growth, not just launch.
Why I Built It in 2 Days
People think speed means shortcuts.
Not necessarily.
Speed comes from:
-
knowing exactly what to build
-
designing before coding
-
removing unnecessary features
Because I’ve built systems for operations teams for years, I already knew:
-
what they actually use
-
what they ignore
-
what slows them down
So instead of experimenting, I executed.
What This Project Proves
Good software isn’t about complexity.
It’s about alignment.
When you align system design with real workflows:
-
teams work faster
-
errors drop
-
reporting becomes accurate
-
audits stop being scary
This project isn’t just another internal tool.
It’s a working operational backbone.
Final Thought
A lot of companies chase flashy systems.
Very few invest in practical ones.
This build reminded me why I enjoy solving real business problems:
When software matches reality, it disappears — and work just flows.
And honestly?
That’s the best kind of system.
Want One for Your Organization?
If your company is still managing assets through spreadsheets, WhatsApp messages, or “bro I think Fiman has that laptop”… then you already know the problem.
I built this system because a real business needed a real solution — not theory, not slides, not buzzwords. Just something that works every day, for real people, in real operations.
If you’re running a company, department, or organization and you think a system like this could help your workflow, feel free to reach out. I’m always open to building practical tools that solve actual problems.
No pressure. No sales pitch.
Just solutions when they’re needed.
