One of the most expensive mistakes in business software development is starting with the interface before understanding how the business actually operates.
A company asks for a dashboard.
The developer starts designing cards, charts, tables, and navigation menus.
A few weeks later, the application looks impressive. But the team still relies on spreadsheets, phone calls, and WhatsApp messages to complete its daily work.
The problem is not necessarily the technology.
The problem is that we designed the screens before understanding the workflow.
My background in sales, digital marketing, and business development has shaped how I approach software engineering. Working with business processes teaches you something that isn't always obvious from a technical specification: what management wants to see and what employees actually need to do are often two different things.
Here are five principles I believe make business software more useful.
1. Start with decisions, not features
A typical requirements document might look like this:
- Customer management
- Order tracking
- Employee dashboard
- Analytics and reporting
- Notifications
These are features. They don't explain the business problem.
A more useful starting point is asking:
What decisions does this system need to support?
For example, in a delivery operation:
- Who should handle the next order?
- What happens if a driver rejects an assignment?
- When is an order considered delivered?
- Who can approve a financial adjustment?
- How does a manager identify an unresolved delivery problem?
Each question leads to a workflow, a business rule, and eventually a technical requirement.
Instead of designing five screens, you begin by understanding five operational decisions.
2. Model the actual workflow
Consider a simplified delivery order:
Created
|
v
Pending Assignment
|
v
Assigned
|
v
Out for Delivery
|
+------> Failed Attempt
| |
| v
| Reassigned
| |
+-------------+
|
v
Delivered
|
v
Financial Settlement
This is an illustrative workflow, not a universal design for every delivery business.
It immediately introduces questions that a dashboard mockup might miss.
Can a completed order return to an active state?
Can two drivers accept the same assignment?
What happens when an API request is retried?
Who is allowed to change a financial settlement?
What records should remain available after a correction?
These questions affect the database, permissions, APIs, background jobs, and audit records.
A business workflow is also a technical architecture problem.
3. Translate business rules into system invariants
A business rule is useful only when the system can enforce it.
Suppose an order can have only one active driver assignment at a time.
That rule shouldn't exist only in a product requirements document.
It needs enforcement at the data layer or within a properly synchronized transaction.
For example, a PostgreSQL partial unique index can express that constraint:
CREATE UNIQUE INDEX
one_active_assignment_per_order
ON driver_assignments (order_id)
WHERE status = 'active';
Now the database rejects a second active assignment for the same order, even if two requests arrive concurrently.
The application still needs to handle that rejection gracefully and explain the outcome to the user.
This is an important distinction:
The interface communicates business rules. The backend enforces them.
Both matter.
4. Design for operational failures
Real businesses don't operate under perfect conditions.
People double-click buttons.
Connections fail.
Customers change their minds.
Employees make mistakes.
External systems respond slowly.
Imagine a delivery-completion request that times out.
The client doesn't know whether the server processed it, so it retries.
Without proper safeguards, that retry might duplicate a financial operation or trigger an unwanted notification.
One approach is to use an idempotency key for operations that must not be repeated.
For example:
POST /api/orders/123/complete
Idempotency-Key: completion-123-v1
The backend can record the key and its outcome, and return the previously recorded result for an equivalent retry.
But an idempotency key alone isn't enough. The implementation must also handle concurrent first requests safely, define the key's scope, and perform the state transition and idempotency recording atomically.
This is not an optional edge case when money or operational state is involved.
It is part of designing a dependable business system.
5. Build dashboards from trustworthy operations
Dashboards are valuable.
But their value depends on the quality of the data beneath them.
A chart showing completed orders means little unless everyone agrees on what "completed" means.
Does it mean the driver marked the order as delivered?
That the customer confirmed receipt?
That the merchant accepted the result?
Or that the financial settlement was finalized?
Each definition can produce a different number.
The same problem appears in sales and marketing.
A lead, a qualified lead, an opportunity, and a closed sale are not interchangeable metrics.
If those definitions aren't consistent across teams, even a technically correct report can mislead management.
Before building analytics, define:
- The business event being measured
- The source of truth
- The timestamp used
- The ownership of the data
- How corrections and reversals are handled
Reliable reporting starts with reliable operations.
Where AI fits into this process
AI can make software development faster, but speed doesn't replace business understanding.
Generating forms, APIs, or components is useful.
Understanding whether a workflow is correct is a different challenge.
For AI-assisted development, I believe the most valuable input isn't simply a list of requested features.
It is a structured description of:
- The business goals
- The actors and their responsibilities
- The workflows and permitted transitions
- The rules that must never be violated
- The expected behavior when things go wrong
The clearer those inputs become, the easier it is to evaluate the software that AI or a human developer produces.
Final thought
My experience in sales and digital marketing taught me to ask what drives a business forward.
Software engineering taught me to turn those requirements into systems.
Today, as the founder of BASMA OS and Founder and CEO of BASGRO, that combination continues to influence how I think about digital products.
A business doesn't need another dashboard simply because dashboards are easy to demonstrate.
It needs software that helps people complete real work, make better decisions, and operate with fewer unnecessary obstacles.
Good business software starts with understanding the business.
What is the most important business rule you've discovered only after starting development?
Hatem Gheta is an entrepreneur and software engineer based in Dubai, and the founder of BASMA OS. He works at the intersection of business development, digital marketing, and software engineering.
Top comments (0)