From customer onboarding and payment processing to agent collaboration, workflow automation, and service delivery.

Introduction

Over the years, I've worked on numerous web development and digital infrastructure projects. One recurring problem I've observed is how businesses rely on disconnected tools to manage their operations.

A customer submits a request through a website. Payment is confirmed elsewhere. Documents arrive through email or WhatsApp. Tasks are assigned manually, and progress updates depend on someone remembering to send a message.

As a software engineer and founder of iWORKS GLOBAL LTD (Nigeria) and Orange Server LLC (USA), I wanted to explore a more integrated approach.

That led me to design and develop the iWorks Global Service Operations Platform: a web application that connects customer onboarding, payments, service delivery, team collaboration, and administrative operations.

This article shares the architecture, technology choices, implementation approach, and engineering lessons behind the project.

1. Understanding the Problem Before Writing Code

The objective was not simply to build another customer dashboard.

I needed a system capable of supporting several interconnected business processes:

  • Customers discovering, ordering, and paying for services.
  • Administrators managing service requests and operational workflows.
  • Remote agents handling assigned jobs and delivering completed work.
  • Finance personnel reviewing transactions, invoices, and commissions.
  • Customers tracking progress and receiving deliverables.

Each role needed different permissions while interacting with shared business records.

This created interesting challenges around authorization, data consistency, payment processing, and workflow management.

2. Technology Stack and Architecture

I chose a PHP and MySQL architecture with server-rendered interfaces and JavaScript-driven interactions.

Core technologies:

  • Backend: PHP 8+, PDO
  • Database: MySQL / MariaDB
  • Frontend: HTML5, CSS3, JavaScript
  • Authentication: Session-based authentication, email OTP, Google OAuth, and role-based access control
  • Payments: Paystack, Flutterwave, Stripe, and other configured payment methods
  • Infrastructure: Apache, Linux hosting, cPanel, HTTPS
  • Development: Git, GitHub, automated checks, and deployment scripts

Rather than immediately introducing a large collection of frameworks and microservices, I worked with a modular PHP application that could run within our existing hosting infrastructure.

The architecture separates authentication, domain logic, data access, reusable helpers, interface templates, and external integrations.

This approach helped me balance operational cost, deployment simplicity, and maintainability.

3. Designing the Multi-Role System

One of the core engineering decisions involved structuring access around user responsibilities.

The platform includes several distinct roles:

Customers can order services, submit information, track progress, communicate, and retrieve documents.

Agents can access eligible paid jobs, claim available work, update assigned tasks, communicate, and submit deliverables.

Administrators manage users, services, job assignments, operational activity, and platform configuration.

Finance personnel have access to relevant payment, commission, and financial administration workflows.

A key principle was ensuring that authorization went beyond hiding interface buttons.

For example, an agent should not be able to retrieve another agent's privately assigned job simply by changing a URL parameter.

The application therefore applies authorization checks when accessing protected routes, job records, and files.

Engineering lesson: User permissions should be enforced by the backend, not just represented by the frontend.

4. Building the Service Delivery Workflow

One of the most important components is the job management system.

The basic workflow looks like this:

Customer Order → Invoice → Payment Confirmation → Job Assignment → Processing → Delivery → Completion

Each stage represents an operational event.

For example, an agent can claim an eligible paid job from the available job pool, while an administrator can assign work to a particular agent.

An assigned agent can then update the job's progress, communicate through the job discussion area, and upload supporting documents.

The platform records status changes and associated activity, making it easier to understand how a request moved through the service lifecycle.

This is particularly useful when multiple people collaborate remotely.

Instead of relying entirely on informal conversations, the application provides a shared record of work.

5. Integrating Multiple Payment Systems

Payments introduced another layer of engineering complexity.

The platform supports payment workflows involving providers such as Paystack, Flutterwave, and Stripe, alongside configured manual payment methods.

One important concern is that receiving a payment notification is not the same as independently verifying the transaction.

The backend includes provider-verification logic that compares returned payment information against recorded transaction details.

Relevant information includes payment references, amounts, currencies, and associated records.

Payment processing also connects to downstream operations.

For example, jobs should not become available for agent processing merely because a customer has initiated checkout.

Engineering lesson: Financial workflows require careful validation, consistent transaction records, and defensive handling of unexpected provider responses.

Payment reliability remains an area where ongoing testing, reconciliation, and concurrency safeguards are essential.

6. Developing the Agent Workspace

I also wanted the platform to support distributed service delivery.

The agent workspace was designed around a practical question:

How can someone contribute to a business operation remotely without needing unrestricted administrative access?

The implemented functionality includes:

  • Access to eligible jobs.
  • Assignment and job claiming.
  • Job status updates.
  • Document uploads.
  • Team messaging.
  • Commission records.
  • Withdrawal requests.

The commission system connects earnings to eligible paid and delivered jobs.

This creates a structured relationship between service execution and compensation records.

It also introduces important requirements around access control, auditability, and payment approval.

7. Authentication, Security, and Data Protection

Security became an important part of the development process because the platform handles customer accounts, financial references, and business documents.

The implementation includes several protective mechanisms:

  • Role-based authorization.
  • CSRF protection for state-changing requests.
  • Email-based verification and OTP workflows.
  • Password recovery.
  • Protected access to uploaded files.
  • Session-management controls.

These mechanisms are part of the application's security architecture, not a claim that every possible risk has been eliminated.

Production software requires continuous review, security testing, monitoring, and maintenance.

One lesson I've reinforced through this project is that security needs to be considered throughout the development lifecycle, rather than added only before launch.

8. Building for Real Business Operations

Beyond the technical modules, I had to consider how the software would actually be used.

A system can be technically functional and still create unnecessary complexity for the people operating it.

That meant paying attention to:

  • Responsive interfaces for mobile and desktop.
  • Clear navigation between operational tasks.
  • Consistent job statuses.
  • Customer-facing progress information.
  • Notifications and communication.
  • Administrative content management.
  • Deployment and maintenance procedures.

The project also reinforced the importance of connecting software design decisions to actual user workflows.

9. Challenges and Lessons Learned

Building this platform has reinforced several important lessons in my software engineering journey.

Start with the business domain. Understanding the relationships between customers, orders, invoices, agents, and payments makes implementation decisions clearer.

Keep permissions explicit. Multi-role systems become difficult to maintain when access rules are scattered or inconsistent.

Treat payment state carefully. A successful checkout interface does not automatically mean that the underlying financial records are correct.

Prioritize maintainability. Clear modules, reusable functions, version control, and automated checks become increasingly important as a product grows.

Build for iteration. Real software products continue evolving through testing, operational feedback, bug fixes, and improvements.

The project is still actively evolving, including further work on reliability, security, and user experience.

10. What's Next?

My focus is on continuing to improve the platform's engineering quality, operational reliability, documentation, and automation.

I'm also interested in exploring reusable components and technical approaches that could benefit other developers working on similar business applications.

As a developer, I believe one of the most valuable ways to grow is to share not only successful implementations but also the challenges and trade-offs involved in building them.

This is my first technical article on DEV Community, and I plan to document more of my engineering work here.

Project links:

I'm interested in hearing from other engineers:

When building a multi-role business application, what has been your biggest challenge: permissions, payments, workflow design, or maintaining the system as it grows?

I'm Afolayan Opeyemi Ayomikun-Oprah, a Full-Stack Software Engineer and founder of iWORKS GLOBAL LTD and Orange Server LLC. I work across software development, business systems, cloud infrastructure, and digital product engineering.