The team works around the system
People export, correct and reload because the real sequence does not fit the available screens.
We build internal dashboards, portals and platforms when an off-the-shelf tool forces your operation to work around the software.
Permissions and layout change by role: production, purchasing and management never see the same screen.
We build on what your team already knows. If the platform has an API or webhooks, it integrates; if it does not, we look for the most stable path before proposing a change of tool.
And any other platform with a public API.
They deliver for several clients with their own vans and with contracted drivers per zone. Every system they had tried treats a delivery as closed or failed, and in this operation an order can come back with half the boxes still inside. We built the software around that case and put it to work in one zone before adding the rest.
Last-mile logistics · Argentina
Delivery systems treat a stop as yes or no: signed or not signed. Here the person receiving can reject part of the order at the door —damaged boxes, a count that does not match the order— and what comes back decides three different things: what gets dispatched again, what gets invoiced to the client and what gets paid to the driver. With a packaged tool that ended up written in the notes field, and somebody retyped it into a spreadsheet on Monday.
Rather than replacing the whole operation, we scoped the first version to what depended on the partial return: recording on the phone what came back and why, and having the driver settlement and the invoicing summary come out of that. Route planning was deliberately left out and kept running on what they already used. It went live in one depot, with the drivers of that zone, and the rest came later.
The driver sees the day’s trip and closes each stop marking line by line what was delivered and what is coming back, with a reason picked from a fixed list. The operations desk sees the stops that closed with a difference and decides whether to dispatch again. Administration sees the settlement per driver for the period and the summary per client. Each role gets its own screen and not the others, instead of the shared spreadsheet everyone used to open. Orders are still pulled from the client’s system by file or API, and the summary is sent to the accounting system they already had: we replaced nothing that worked.
Zone rates, return reasons and each client’s rules are loaded from an admin screen: adding a new client means loading its rules, not asking for development. There is a short document explaining every screen, every state and what happens when a stop closes with a difference. Improvements go into a list that gets ordered once a month: whatever blocks today’s operation goes in, the rest waits.
The same mechanics fit any operation where the work does not end in yes or no: a lab where a sample has to be run again, a builder certifying partial progress on site, a service call that leaves equipment half working. The vocabulary and the states change, the way it is built does not.
Not every process deserves custom code. But when adapting to a tool removes an advantage, multiplies spreadsheets or demands too many workarounds, building can be the simpler option.
People export, correct and reload because the real sequence does not fit the available screens.
Orders, documents and statuses run through email because no portal holds the full workflow.
Reports require manual consolidation and explain what happened after the chance to intervene has passed.
We do not replace every tool. We design the missing piece and integrate it so the user sees one flow even when several systems participate behind it.
Queues, priorities, states, alerts and owners in a view built for making decisions.
Orders, documents, tracking and communication without depending on email chains.
Specific rules, approvals and exceptions that a generic product cannot represent well.
APIs, synchronisation, identity and reporting so the new platform does not become another silo.
Architecture is designed to grow, but the project is validated by one real operational slice. Every release has users, data and an observable result.
Who uses the system, what they need to resolve and which data allows them to move.
Navigable screens and rules before investing in the full implementation.
Small, integrated releases tested with people who own the process.
Monitoring, support, documentation and evolution driven by evidence of use.
The project covers product, interface, engineering and launch. We do not hand over code without the context required to operate and evolve it.
When the process is an advantage, no product fits without costly compromises, or current fragmentation costs more than owning a solution.
We choose the stack around the problem, maintainers, integrations, security and scale. The decision is documented and not driven by fashion.
The contract defines ownership and access from the start. The company receives the agreed repository, documentation and deployment control.
It depends on scope. We work towards a usable first release and later phases so the product is validated before months are committed to the full solution.
Yes. We can support operations, incidents and evolution, with responsibilities and service levels defined according to system criticality.
We assess whether it genuinely needs custom software or whether configuring and integrating existing tools is enough.
Kai Kommit agent · Online
Hi — I'm Kai, Kommit's agent. Tell me which process is costing you hours and I'll tell you where to start.
AI agent: it can be wrong. Anything agreed is confirmed by the team. Prefer the form →