Integrated Algorithm Engineering and Serverless Architecture for Rapid Business Iteration

Background – With the rapid expansion of Amap (Gaode) map services, the demand for algorithmic strategies in various small‑to‑medium business scenarios (e.g., shared mobility, risk control, scheduling, marketing) has grown dramatically. Traditional long‑cycle, high‑traffic, low‑latency navigation architectures can no longer meet the fast‑iteration needs of these emerging services.

To address this, an integrated architecture was adopted, where algorithm development and engineering are unified. Data, systems, and the entire pipeline are connected, enabling systematic data flow, automated testing, and intelligent validation, thus forming a closed‑loop that accelerates business iteration.

In the early stage of a project, QPS is typically low (<1k), making conventional development and deployment inefficient and resource‑intensive. The goal is to achieve “offline strategy research → immediate service deployment,” reducing the time from algorithm exploration to production. Because performance pressure is modest, rapid Python development offline becomes feasible.

As the business matures, algorithm composition, service call volume, and performance become critical evaluation metrics, prompting forward‑looking optimizations such as high‑performance core algorithm implementations.

The integrated algorithm‑engineering process therefore supports the evolution from startup to mature phases.

Overall System Architecture

The platform consists of four logical components:

Unified Access Gateway Service

Business Algorithm Exposure Service

Algorithm Model & Code Management Service

Quality Assurance System

Note: GBFC is the data service layer that supplies data and features to algorithm services, ensuring statelessness and facilitating data sharing across business lines.

Unified Access Gateway

The gateway isolates various algorithm APIs, providing both atomic and composite services. It standardizes API access for business teams (e.g., value judgment, risk prediction, recommendation), monitors performance and availability, and aggregates data for feature generation and online learning.

Common preprocessing functions such as authentication, routing, rate‑limiting, circuit‑breaking, gray releases, A/B testing, and “shadow” runs are handled at the gateway, ensuring scalability and reliability. Service composition (e.g., voice recognition, image processing) is also supported, allowing business logic to remain simple while complex processing is orchestrated behind the scenes.

Because these requirements demand a flexible, lightweight, stateless backend, a Serverless architecture is an ideal fit.

Business Algorithm Services on Serverless

Serverless (FaaS) offers a lightweight, stateless execution model with rapid start‑up, making it well‑suited for early‑stage algorithm experimentation despite occasional cold‑start overhead.

Developers can write algorithm services locally in Python and publish them directly as Functions. This eliminates the traditional hand‑off between algorithm and engineering teams, reducing communication overhead and enabling truly atomic, reusable services.

After establishing a Python runtime that supports models such as PMML and TensorFlow, the roadmap includes adding Golang and Java runtimes. Golang is chosen for its strong concurrency support, meeting performance needs while keeping development simple.

While algorithm atomization and function‑as‑a‑service empower algorithm engineers to own production services, they also raise concerns about service stability, engineering quality, and correctness. Simply shifting these responsibilities to algorithm developers would increase operational risk, making a robust quality‑assurance system essential.

Quality Assurance System Construction

Quality assurance is not limited to manual testing; it must be fully automated. The typical strategy research workflow includes data analysis, algorithm design, data validation, manual/automatic evaluation, and iterative refinement. These steps naturally generate datasets for validation, testing, and performance measurement.

Algorithm engineers can automate stress testing (outputting QPS, RT, consistency), stability testing (using validation datasets), logical correctness verification (using test sets), and effectiveness evaluation (using validation sets). In fast‑iteration scenarios, automated A/B testing and “shadow” deployments further ensure comprehensive quality assessment before full rollout.

Conclusion

The unified algorithm‑engineering construction satisfies rapid‑iteration requirements in early‑stage projects. Success hinges on clear recognition of the business phase, stateless function‑based services, and a solid feature‑service layer that enables data sharing and co‑construction.

While this architecture meets most business‑driven algorithm needs, compute‑intensive AI projects still face hardware bottlenecks. Emerging compute‑storage‑integrated hardware aims to break these limits.