Project Goals
The goal of the Costimator project was to develop an automated system for calculating the cost of a specific product on a particular day under specific conditions for a large-scale corporation. The system was designed to replace the manual, labor-intensive process of determining prices, which previously required input from multiple individuals across different departments. By automating this process, the system aimed to improve efficiency, accuracy, and the speed of price determination, ultimately enhancing the corporation's overall productivity and increasing the number of deals.
Functional Capabilities
- Automated Price Calculation: The system calculates the cost of a product for purchase at a specific point in time by a particular partner or buyer. It takes into account numerous factors, including:
- Product Availability: Whether the product is in stock, reserved, or needs to be produced.
- Warehouse and Delivery Options: Whether the product is available for pickup at a warehouse or needs delivery, and from which warehouse it can be delivered.
- Special Agreements and Discounts: The system factors in partner-specific discounts, special agreements, and other pricing conditions that may affect the final cost.
- Price Determination Without Manual Involvement: The system allows for accurate price determination without the need for multiple individuals from different offices to be involved, reducing the complexity and time required for price calculations.
- Real-Time Pricing: The system provides the ability to determine the exact price at any given day and moment, considering all nuances, allowing for quick responses to partner or buyer inquiries.
- Extensive Documentation: Extensive documentation was created, including guides for end-users, to ensure that the system could be easily used and maintained by all stakeholders. Tools like Confluence and Jira were intensively used for requirements management and project tracking.
Solution Concept
The Automated Product Cost Calculator was developed to address the challenges faced by a large corporation with numerous factories, warehouses, and products. Given the complexity of determining prices for thousands of products across multiple countries, with varying exchange rates, transportation conditions, and special agreements, a manual pricing process was inefficient and prone to errors.
The system was designed using a microservice architecture, enabling scalability and fault tolerance. This architecture allowed for individual components of the system to be scaled as needed to meet performance and reliability requirements.
The backend was developed using .NET Core and C#, while the React framework was used for the frontend to provide an intuitive user interface. MS SQL served as the primary database for storing product, warehouse, and pricing information. The system was deployed on both Windows and Linux environments, with IIS used for web server hosting.
The system was designed to be highly performant, with the ability to calculate product costs in real-time, replacing the previous manual process that could take up to 24 hours. The new automated system now performs the same task almost instantly, providing significant improvements in efficiency.
Results
- Improved Efficiency in Price Calculation: The process of determining product prices, which previously took up to 24 hours, now takes just a few seconds, significantly increasing the speed and efficiency of operations.
- Increased Productivity: By automating the pricing task, the overall productivity of the corporation increased, as employees were no longer required to manually calculate prices.
- Increased Deal Volume: The ability to determine prices promptly led to an increase in the number of deals, as partners and buyers received faster responses to pricing inquiries.
- Scalable and Fault-Tolerant System: The use of a microservice architecture ensured that the system could scale to meet the demands of the corporation's extensive operations while maintaining high reliability and fault tolerance.
Technologies and Architecture
- Backend Development:
- .NET Core and C#: Used for developing the core pricing logic and backend services, providing a scalable and robust solution for the corporation's pricing needs.
- Frontend Development:
- React: Used to develop the user interface, providing an intuitive and responsive experience for users interacting with the system.
- Database Management:
- MS SQL: Utilized as the primary database for storing product information, warehouse details, pricing conditions, and other relevant data.
- Microservice Architecture:
- The system was built using a microservice architecture, allowing individual components to be scaled independently based on performance and reliability requirements.
- Deployment and Integration:
- IIS: Used as the web server for hosting the frontend and backend services.
- ZooKeeper and Kafka: Integrated for managing microservices and ensuring smooth communication between different system components.
- Operating Systems:
- Windows and Linux: Supported for both the client-side and server-side components, providing flexibility in deployment options.
- Project Management Tools:
- Confluence and Jira: Used extensively for requirements management, documentation, and project tracking, ensuring clear communication and alignment among team members.
User Cases
- Sales and Support Teams: The system provided sales and support teams with the ability to quickly determine the price of a product for a specific buyer, without needing to involve multiple individuals or manually calculate the price.
- Partners and Buyers: Partners and buyers received accurate, real-time pricing information, allowing them to make informed purchasing decisions more quickly.
- Management: Management used the system to monitor pricing trends and ensure that the pricing conditions were applied consistently across all products and buyers, improving the overall transparency of the pricing process.
Integration and Development Process
- Requirements Gathering: The project began with gathering requirements from the corporation's sales, support, and management teams to understand their specific needs for pricing automation and the factors that influenced product costs.
- System Design and Architecture: The system architecture was designed using microservices to ensure scalability and fault tolerance. The backend was developed using .NET Core and C#, while the frontend was built using React.
- Team Formation and Leadership: A team of software developers, system architects, and project managers was formed to develop and implement the system. The development process followed an iterative approach, allowing for continuous feedback and improvements.
- Implementation and Testing: The system was implemented iteratively, with regular testing to ensure that the pricing logic met the needs of the corporation. The use of ZooKeeper and Kafka ensured that the system components communicated seamlessly, even under high load conditions.
Client Benefits
- Reduced Manual Effort: The automated system eliminated the need for manual price calculations, significantly reducing the workload for employees and freeing them up to focus on higher-value tasks.
- Faster Price Determination: The ability to determine product prices in real-time improved the speed at which the corporation could respond to partner and buyer inquiries, enhancing customer satisfaction.
- Increased Deal Volume: The prompt determination of product prices led to an increase in the number of deals, contributing to the overall growth of the corporation.
- Scalable and Reliable System: The use of a microservice architecture ensured that the system could scale to meet the demands of the corporation's extensive operations, while maintaining high reliability and fault tolerance.