How a Securities Firm Accelerated Delivery with a Custom DevOps Platform

Background

DevOps combines development and operations practices to enable fast, reliable software delivery. By automating build, test, and deployment, organizations can reduce lead time from months to weeks, improve quality, and lower operational costs. In the securities industry, agile development and DevOps are essential for rapid iteration of fintech applications.

Platform Overview

The "Hummingbird" performance‑management platform implements continuous integration (CI), continuous delivery (CD), and continuous operation (CO) across multi‑environment (development, testing, pre‑release, production) clouds. Its architecture consists of three layers:

Infrastructure layer : private, Huawei, and industry clouds provide the underlying compute, network, and storage resources.

Tool layer : Jira for requirement management, Git for source control, Kubernetes for container orchestration, Harbor and Artifactory for artifact storage, and monitoring tools.

Value‑stream layer : delivers CI/CD pipelines, automated testing, release approval workflows, and performance‑metric tracking to functional roles.

Key Technical Components

1. JIRA Integration

Requirements are linked to release iterations. When developers submit a test request or a release, they select the corresponding STORY from JIRA, ensuring traceability of code changes to business value.

2. CI/CD Pipeline Design

The pipeline consists of the following stages:

Static code scanning (incremental on each commit, full scan before release).

Build: source code is compiled and Docker images are created in GitLab CI.

Artifact promotion: images are pushed to Harbor, non‑image artifacts to Artifactory.

Deployment to development environment (automatic).

Test environment deployment (on‑demand, after approval).

Production deployment (approval workflow, optional rollback).

Role‑based approvals enforce compliance at each promotion step.

3. Code Management and Build

Git is used with the GitFlow branching model:

# Example GitFlow commands
git checkout -b develop               # create develop branch
git checkout -b feature/xyz          # start a feature
git checkout develop && git merge feature/xyz   # integrate feature
git checkout -b release/1.0.0          # create release branch
git checkout master && git merge release/1.0.0 # finish release
git checkout -b hotfix/bug123          # hot‑fix on master

This model isolates feature development, stabilizes releases, and simplifies CI/CD triggers.

4. Artifact Repository Management

Docker images are stored in Harbor , providing vulnerability scanning and RBAC per repository. Non‑image artifacts (JARs, ZIPs, etc.) are stored in Artifactory . Permissions are granted per repository account to guarantee traceability.

5. API Management

All service interfaces are centrally defined. The platform supports:

Front‑end/back‑end API calls.

Multi‑project API governance and versioning.

Interactive debugging and mock responses.

Automated API testing integrated with the CI pipeline.

6. Configuration Center

Based on Apollo , the configuration center manages system parameters across development, testing, and production clusters in hybrid‑cloud environments. Changes are pushed in real time, and access is controlled by permissioned workflows.

7. Unit Testing and Static Code Scanning

Unit tests run automatically on each commit; results are fed back to developers via the platform UI. Static analysis detects common defects such as resource leaks, security vulnerabilities, null‑pointer dereferences, and concurrency issues. Promotion to the next environment is blocked until all high‑, medium‑, and low‑severity issues are resolved.

8. Automated Functional, API, Performance, and UI Testing

Functional and API tests are written with unittest + ddt in Python, producing HTML reports. UI automation uses Appium :

iOS: XCUITest driver.

Android: UiAutomator driver.

Example of a data‑driven API test:

import unittest, ddt, requests

@ddt.ddt
class APITest(unittest.TestCase):
    @ddt.data(
        ("/login", {"user":"admin","pwd":"123"}, 200),
        ("/login", {"user":"bad","pwd":"xyz"}, 401)
    )
    def test_login(self, endpoint, payload, expected_status):
        resp = requests.post(f"http://api.example.com{endpoint}", json=payload)
        self.assertEqual(resp.status_code, expected_status)

if __name__ == "__main__":
    unittest.main()

9. Hybrid‑Cloud Management and Production Release

The platform orchestrates Kubernetes clusters across private, Huawei, and industry clouds. CI/CD artifacts flow seamlessly between clouds, enabling a single source of truth for container images and configuration.

10. Automated Monitoring and Operational Support

Runtime metrics (CPU, memory, latency) and fault data are collected automatically. The platform can trigger self‑healing actions (e.g., pod restart) and generates incident reports that are fed back to developers for rapid root‑cause analysis.

11. Performance‑Metric Tracking and Improvement

Key indicators visualized on dashboards include:

Code statistics (lines of code, commit frequency).

Test automation coverage.

Deployment throughput (cycles per day).

Demand cost/value ratio.

Operational incident rate.

Results and Benefits

Since launch, the platform has executed over 60,000 CI/CD cycles for more than 180 projects . Measurable improvements:

Lead time from development to production shortened by up to 10× .

Static code scanning completes in 10–20 minutes per application.

Full regression testing reduced from 2–3 days to 6–8 hours .

Production incidents decreased due to early defect detection and container‑based environment isolation.

Overall, the Hummingbird platform demonstrates how a DevOps‑driven, container‑native solution can dramatically increase delivery speed, quality, and operational visibility in a regulated financial‑services environment.