SaaS-Based ERP App Enhancements: Case Study

Technology Stack

.NET Core
Angular v14
Syncfusion
Docker Compose
Kubernetes
MSSQL
MongoDB
MS Azure

The Client

The client owns a SaaS-based ERP application that companies can use for any business requirement they want. The app helps companies with enterprise resource planning (ERP), such as accounting, sales, supply chains, customer relationships, human resources, finances, etc. It allows companies to store and centralize their enterprise-wide data. The ERP app also helps companies get a 360° view of various business operations within a single space.

The Challenge

The ERP application was already live for some time. But, the client started seeing loopholes in the app’s technical architecture. The loopholes were primarily because of poorly-written rule engines.

Rule engines are libraries that pull the business logic out of a system’s core structure. That is, they decouple logic from an application’s core. This decoupling helps developers make rapid changes in business rules/logic without affecting the application as a whole.

But, our client’s existing ERP app had badly-written rule engines. Many of these rules were not appropriately responding to specific events, user inputs, or actions. So, our client wanted a highly-skilled development partner who could do the fixes and define the rules correctly.

After going through Capital Numbers’ portfolio, the client found a trusted partner in us. So, he reached out to us for help.

Our primary challenge was to understand the flaws in the existing rule engine designs. We then had to come up with deep-nested logic. We had to skillfully match algorithms to define which rule should run when and in what order. The work required us to develop several intelligent ‘if-this-do-that’ conditional statements.

Our next challenge was to fix the caching. We saw that the existing cached memory didn’t clear off data when users logged out. As a result, the app would load slowly. So, we had to offer solutions that improve the data retrieval process and clear off cache data when users log out.

Our third challenge was to upgrade the frontend framework. We had to add new UI components like menus, lists, boxes, drag-and-drops, etc. A version upgrade was, therefore, crucial.

The Solution

After noting the key challenges, we began the project with an as-is analysis. We checked the deep-seated issues and implemented the following solutions:

Firstly, our examinations confirmed multiple areas were error-prone. So, we removed those errors and wrote powerful rule engines in the existing .NET Core backend environment. We resolved complex, underlying issues using Data Structure and Algorithm (DSA) techniques. We also double-checked algorithmic efficiencies after implementation.

Next, we created a cache memory store. We did this to help the app fetch user-requested data from the cache (a quicker process) and not from the main memory (a lengthy process). We also ensured the cache store clears temporary files when users log out.

We then worked on the app frontend. We upgraded it from Angular v10 to Angular v14 because the latter offers a variety of reusable templates and custom page title options. The v14 also helps customize menus, tables, overlays, dialogs, drag-and-drops, etc. So, upgrading to v14 was essential.

In addition, we used Syncfusion to design UI elements on a granular level. Syncfusion is an excellent tool for creating data tables, grids, charts, graphs, etc. We also build logic to connect the frontend with the backend data.

Next, we used Docker Compose to containerize different microservices (Finance, HRs, Customers, etc.) within this single ERP solution. Containerization puts less load on servers. We also used Kubernetes to manage the individual containers (microservices) efficiently.

Our experts used two database solutions for the ERP app. We chose MSSQL because it allows excellent data restoration and recovery. We also used MongoDB because it scales well and has outstanding data-querying ability.

Once we implemented it all, we did unit testing using xUnit.net to check if the backend functions were running correctly. After a thorough quality check, we deployed the app in MS Azure, as Azure is excellent at processing enormous data volumes.

We regularly collaborated with the client over Slack, Google Meet, and GitLab. Our open communications further impressed our client and helped with solution deliveries better.

Results

The outcome is an improved ERP app that is more workable and functional. The app is better equipped to handle CRMs, Sales, Accounts, Finance, and HR tasks. Here’s more on the final results:

New Rule Engines

Our well-written rule engines help the app perform better without requiring repetitive manual inputs. For example:

In the Finance module of the app, if a user manually inserts Vendor Name and Payment Amount, a Vendor Ledger box gets automatically created to summarize:

Vendor Name
Amount Paid
Payment Date
Payment Type

Insert/Update/Upsert Operations

Our rule engines also support Insert/Update/Upsert operations.

Insert helps update a single row in a data table.
Update helps add new value to a data table.
Upsert does both, i.e., helps add a new row and value in a data table.

Improved Module Management

Because of our solutions, the app helps users better manage ERP modules. For example:

Human Resources
Sales
Customer Relationships
Finance

Granular Insights

We brought granularity by creating sub-modules under each main module. For example:

HR - Recruitment, HR Exec, Employee, Training, etc.
Sales - Leads, Marketing, Commissions, etc.
Customer - Order Tickets, Billing, etc.
Finance - Vendors, Bills, Expenses, etc.

Macro Data and Reports

We also showed macro-level data and reports under each sub-module. For example:

HR Exec - No. Of Applicants, Location, Average Salary, etc.
Commissions - Commission Plan, Sales Agent, Sales Referral, etc.
Billing - Recurring Billing Items, Credit Memos, Invoices, etc.
Finance Bills - Vendor Bills, Vendor Payments, etc.

Clear Visibility and Tracking

We showcased the above data points and reports in clear tabular formats.

Improved App Speed

Because we created a new cache memory, the data retrieval process is now super-fast.

Backend and Frontend Synchronizations

Our custom solutions help sync backend and frontend data well.

DSA Capabilities

Our DSA implementations help a lot with data segmentation and algorithm structuring.

Reusable UI Elements

Our UI solutions make templates, links, menus, tables, charts, etc., reusable and scalable.

Reduced Infra Costs with CI/CD

Our DevOps team skillfully used CI/CD tools to release rapidly and keep costs low.

A Successful Dedicated Development

The way we brought forth these solutions to step up the capacity of the ERP app was well-liked by our client. He appreciated our prolific team (combining .NET, Angular, QA, and DevOps experts), who worked dedicatedly on this project.

Second Phase of Enhancements

Preferring Capital Numbers over other vendors, our client sought our help again to implement additional rule engine designs in the same ERP app. This time, we are working on: