AdTech Bidding Module Development

About the client

Our client is a programmatic audio advertising integration company. They operate a complex AdTech platform that connects game publishers and advertisers and enables transactions between these two parties.

Goal

The client’s AdTech platform comprises different functional parts/modules. They required qualified developers to work on one of the modules – the Bidding part based on complex business logic. It was written in Python and had issues with raw sense, memory leaks, and unsatisfactory performance. 

The client required qualified resources to improve inner logic, refactor code, and maintain the necessary execution speed, among other things.

Work Description

Project’s background:

The client’s RTB-powered platform brings together game developers and advertisers and facilitates transactions between the parties in the following way. Game representatives contact the company, register on the platform, sign a contract, and provide information necessary for processing, including the type of device, user age, audience preferences, etc. This data flows to the Mediation server , where the incoming data is processed and shipped to the Bidding part.

The Bidding module consists of two microservices: Engine and Listener services. The Engine service is designed to accept, validate, and process incoming requests from the Mediation server. The Listener service aims to produce logic for finding a match based on multiple criteria, making budget calculations, and implementing other aspects of business logic. Specifically, it is crucial to adhere to strict processing limits within 200 milliseconds per request.

Resources provided:

Geomotiv provided a team who worked with the tech lead on the client’s side to implement the desired milestones.

Engagement model:

We provided several specialists under the IT staff augmentation engagement model. This approach enabled our client to incorporate skilled external resources into their existing hybrid team and capitalize on their expertise and specialized skills required to develop and improve complex programmatic pipelines.

Approach:

Recognizing the dynamic nature of the project, the client adopted the Agile methodology to streamline and enhance the development process. Our specialists actively engaged in daily stand-up meetings, fostering real-time collaboration through communication channels such as Slack and Google Meet . In addition, the team leveraged a Jira board to manage and track the project’s progress, ensuring transparency, fair task allocation, and a cohesive workflow. This approach facilitated adaptive planning and empowered the team to respond to evolving requirements, promoting a collaborative and iterative software development environment.

Developers’ role:

• Read, maintain, and improve project documentation to refine bidding process workflows;
• Assist other team members with ongoing development tasks;
• Refactor underlying Python code using Go;
• Participate in the formation of a bidding mechanism and maintain its logic;
• Write tests, check detected issues, and add changes to the code based on identified roadblocks;
• Set up and monitor CI/CD pipelines;
• Monitor and optimize the system’s inner workings.

Project scope:

Software development and testing tasks.

The team played a crucial role in enhancing the client’s Bidding module by focusing on code refactoring and restructuring in Golang . Code simplification and refactoring in Golang led to reduced RAM usage, eradication of memory leaks, and acceleration of request processing. 

Additionally, our team was engaged in testing the Bidding module’s capabilities and performance. This involved writing tests on GitHub and pushing them to Google Cloud, assessing load capabilities, and analyzing metrics to measure the system’s processing speed and response times. Our developers created automatic deployment to various Google Cloud environments, covering over 85% of the entire code with tests on each Bidding service.

In the project’s early stages, the team initiated a task to enhance testing efficiency. Our specialists created a script designed to gather data from the production environment, databases, and other sources, subsequently forwarding this data to the local system. This approach proved valuable for testing code locally using authentic data. By running the script, developers could aggregate all the data into a local database and thus streamline development efforts by 40%.

System monitoring and optimization activities.

Moreover, the team actively monitored and optimized the Bidding system. This included evaluating request processing speed, overseeing system load, and resolving upcoming issues with microservices. Specifically, it was crucial to adhere to hard limits of 200 milliseconds per request and proactively implement measures to avert system slowdown.

One of the problems detected during these activities was successfully solved with our developers’ help. The team usually initiates the database connection and runs the server when writing microservices. In the event of an error causing program failure, error logs would be typically displayed in the console, providing insights for debugging. 

While these logs appear locally to the developers, they are not visible when the application runs on the production server. This situation leads to uncertainty about the cause of potential malfunctions. To address this recurring issue, our developers implemented an integration enabling the uploading of logs from the local environment to a shared Google Cloud server. This integration facilitated comprehensive analysis and fast issue resolution in the production environment.

Producing and improving documentation.

The team updated and maintained project documentation to enhance clarity and understanding. Our specialists documented revised logic, created illustrative diagrams depicting the desired application behavior, and outlined architecture design in comprehensive documentation.

Work Stages

1. Sprint Planning and Discussion
2. Implementation
3. Review
4. Release
5. Testing
6. Next Sprint Planning

Results

In collaboration with the client’s team, Geomotiv’s software developers played a crucial role in enhancing the performance and capabilities of the Bidding system. With meticulous attention to detail, our team suggested and implemented the most optimal approach to code refactoring, detected and fixed bugs, and monitored the solution’s KPIs to meet rigid performance limitations.

With the help of our team, it became possible to:

• accelerate the development work by 40%;
• refactor all the underlying code, thus making it clean and readable;
• improve test coverage from 20% to 85% and automate testing tasks;
• reduce memory leak by 60%;
• improve the internal logic of the Bidding system;
• structure the codebase and refactor code for optimized performance;
• meet the rigid limits of processing speed – up to 200 milliseconds per request.