The RunnerGo testing platform provides API debugging, automation, and performance testing through a multi‑service online architecture that includes management, engine, collector, front‑end, and various middleware components such as Redis, MySQL, MongoDB, Kafka, and Nginx, illustrated with architecture and process diagrams.
The article examines a real‑world incident where an unsafe Redis command caused a $4 million loss, then demonstrates performance testing with ten million keys, shows how to disable dangerous commands, replace KEYS with SCAN, and avoid big‑key issues for safer database operations.
The article explains how continuous testing, performance testing fences, acceptance test nets, and package‑dependency checks using tools like ArchUnit can create feedback loops that prevent architectural decay, improve quality, and support safe migrations in modern software projects.
This article provides software test engineers with 1‑3 years of experience a comprehensive roadmap to master fundamental testing skills, automation, performance, security testing, and essential programming languages, emphasizing systematic learning, practical application, and continuous improvement for career growth.
This report details the background, implementation, and results of using the JSF 1.7.6 dynamic preheat strategy to mitigate performance spikes during service deployments on JD's VOP platform, comparing scenarios with and without preheat and providing concrete monitoring data and configuration guidance.
This article explains what benchmarking is, introduces the JMH framework for Java, shows how to add JMH dependencies, walks through a simple "Hello JMH" example with full source and output, demonstrates using JMH with Spring Boot, details the most important options and annotations, and highlights common pitfalls to avoid when writing reliable micro‑benchmarks.
This article explains what performance testing is, its goals, key metrics, common test types, and provides a step‑by‑step guide—including tool selection, requirement clarification, environment setup, script design, execution, and result analysis—using the RunnerGo platform for newcomers.
This article analyzes the challenges of traditional system load testing, proposes an iterative testing workflow that enhances service and environment stability, reduces manpower and timeliness costs, aligns testing with business needs, and outlines the evolution of a full‑process testing model with practical feedback.
This article details a comprehensive performance testing workflow—including requirement analysis, script recording with BlazeMeter, data construction, iterative optimization, and final results—targeting a web application that must handle over 5,000 TPS with 2 million database records, highlighting bottlenecks in Redis, MySQL, and code logic.
This guide explains how to create, configure, and debug visual test scenarios in RunnerGo—using a login‑random‑value example to illustrate interface creation, conditional controllers, wait controllers, and scenario debugging for realistic performance testing workflows.
Continuous testing, performance testing fences, acceptance test nets, and ArchUnit dependency checks are presented as practical strategies to prevent software and architecture decay, illustrated with real project experiences, CI/CD integration, and code examples for robust quality assurance.
This step‑by‑step guide introduces JMeter, explains how to download and install it (including Java setup), walks through creating a simple test plan with thread groups, HTTP samplers, and listeners, and shows how to run and analyze results, enabling beginners to quickly start performance testing.
RunnerGo is an Apache‑2.0 licensed full‑stack testing platform built with Go and React that provides API testing, scenario automation, performance testing, and rich reporting, and the article details its features, technology stack, architecture, installation steps, configuration files, and open‑source repositories.
This tutorial explains how to use RunnerGo to set different concurrency levels for each interface of a news app by assigning interface weights, demonstrating the calculation of mixed concurrency and providing step‑by‑step instructions with screenshots.
This article explains performance testing fundamentals, why it matters, the specific challenges Yidun faced such as complex execution, human‑dependent monitoring, data isolation, and cost loss, and describes their automated, gradient‑based testing platform with quantified monitoring and future visualisation plans.
This article presents a detailed overview of payment system architecture, describing the transaction and payment cores, their interactions, service governance, asynchronous processing, data consistency, and practical production practices, while illustrating each concept with diagrams and code snippets.
This article explains the LSM‑Tree foundation of OceanBase, details its tiered and leveled compaction strategies, and presents two experiments that observe Mini and Minor compactions under different configuration parameters, revealing how minor freeze and trigger settings affect data movement between L0 and L1 layers.
This article presents a systematic method for evaluating and prioritizing stress‑test coverage in game projects, combining comprehensive “addition” techniques—such as QA requirement gathering, case‑library reference, test‑case review, and server‑architecture analysis—with precise “subtraction” methods to refine the final test set.
This article explains the definitions and differences between QPS and TPS, explores related concepts such as concurrency, throughput, PV, UV, DAU, MAU, and outlines practical methods for evaluating system performance and capacity planning.
This comprehensive guide introduces distributed tracing challenges in large microservice systems, explains what Apache SkyWalking is, compares it with Zipkin, Pinpoint and CAT, details performance test results, walks through installation, configuration, custom tracing, log integration, alerting, and high‑availability deployment.
This article details the technical architecture, testing workflow, performance standards, and monitoring strategies Taobao uses to ensure low‑latency, high‑quality 3D cloud‑rendered experiences in its Future City virtual commerce platform.
Yidian Tianxia tackled massive daily data volumes and complex analytics by defining a five‑layer data‑warehouse standard, comparing ClickHouse and StarRocks performance, and implementing a unified real‑time/offline architecture with StarRocks, DataPlus, and EasyJob, achieving multi‑fold query speedups and lower operational costs.
This article details how SelectDB’s data technology architect designed and implemented a new stream‑batch unified data platform using Apache Doris, covering the shortcomings of the early CDH‑based architecture, the selection process, data modeling, ingestion pipelines, performance testing, operational optimizations, and future plans.
The article outlines three common pressure‑testing challenges—how to extract test points, how to obtain realistic target metrics, and how to design test strategies—then demonstrates single‑scenario load, mixed‑business load, and long‑duration stability tests using JMeter with stepwise thread ramp‑up and metric analysis.
This article compiles a comprehensive set of software testing interview questions covering test planning, test case design, bug identification, communication with developers, PO pattern usage, automation frameworks, API testing, performance testing, and related best‑practice answers to help candidates prepare effectively.
This guide explains how to use Java's java.lang.management APIs to retrieve real-time JVM CPU usage, system load averages, garbage collection details, and heap/non‑heap memory statistics, providing code snippets and practical usage scenarios for performance testing and resource allocation.
This guide explains how to prepare a Go environment, install and configure the goreplay (gor) tool, capture real HTTP traffic from production, and replay it in a test environment with options for filtering, scaling, looping, and real‑time playback to achieve accurate performance testing.
For Taobao’s 2022 Double 11 interactive games, a comprehensive QA approach combined online stress testing, reinforcement‑learning‑driven case generation, and systematic fault injection—addressing high‑concurrency, data‑consistency, and client‑performance risks through traffic shaping, data and middleware isolation, and automated tools (Wali, DaBai) that delivered over 60 smoke cases, 76 % coverage and 82.6 % fault detection.
The article explains performance testing as a non‑functional testing activity within continuous testing, describes its various types, compares process/thread/coroutine execution models, evaluates tools like LoadRunner, JMeter and Locust, and outlines desired features for container‑friendly performance testing solutions.
This article introduces Turbopack, a Rust‑based successor to Webpack, explains its incremental caching, on‑demand compilation, SWC compiler, persistence and import support, demonstrates its speed advantages with Next.js benchmarks, and discusses current ecosystem challenges and future prospects.
The article outlines a comprehensive stability‑assurance framework for large‑scale promotional events—detailing planning, capacity and pressure‑test rehearsals, strict change‑freeze, internal gray releases, coordinated on‑call response, thorough link and capacity analysis, monitoring, emergency procedures, cross‑team collaboration, external partner coordination, and post‑event review to ensure resilient system performance.
To ensure Kun’s Flutter‑based container upgrades improve Xianyu’s user experience, we introduced a layered performance testing framework that defines industry‑standard metrics, component‑ and business‑level benchmarks, multi‑dimensional stress and regression checks, automated scripts, expanded device pools, and streamlined task creation, delivering faster insights, higher stability, and actionable optimization feedback.
The study benchmarks Tencent Cloud KeeWiDB with YCSB workloads, showing that its Redis‑compatible KV service delivers up to 149 k QPS reads and 127 k QPS writes for 128‑byte strings, out‑performing self‑built Pika and Redis clusters, though larger values suffer bandwidth throttling, confirming KeeWiDB as a low‑cost, high‑performance option for small‑value, read‑heavy use cases.
This tutorial walks through setting up an Elasticsearch server, creating a Java REST client, implementing a custom GET‑with‑body request, building a reusable ESClient wrapper with common CRUD and search methods, and providing Groovy performance test cases for indexing and querying.
Facing rapid growth and high write loads, HuoLala replaced HBase with kvrocks for trace data storage, evaluating Leveled, Universal, and FIFO compaction strategies, optimizing configurations, and ultimately achieving stable operation with up to 70 k QPS, near‑hundred terabytes of data, and a 55% cost reduction.
This article explains key system performance testing metrics such as response time, concurrency, click‑through rate, throughput, TPS/QPS, PV/UV, and details essential Linux server indicators like CPU usage, memory utilization, load average, and disk I/O, providing formulas, interpretation guidelines, and useful command‑line tools.
Facing hundreds of terabytes of daily monitoring data, Huawei Cloud SRE replaced HBase with the open‑source time‑series database openGemini, conducting extensive write and query performance tests that demonstrated linear scaling, superior query speed, and significant reductions in storage, CPU, and memory usage.
A low‑load performance test compares three ways of selecting an array index—using Math.random(), a sequential int counter, and AtomicInteger—revealing that the random‑number approach consumes significantly more CPU while AtomicInteger spikes memory usage under higher loads.
To cope with the multi‑stage, feature‑rich and rapidly iterated NetEase News recommendation pipeline, the QA team introduced detailed stage logging, controllable recall and user‑profile injection, configurable filters, forced‑push mechanisms, an integrated performance‑testing platform, automated case configuration, centralized requirement tracking, and self‑test tools, dramatically boosting testing quality and efficiency while outlining future automation goals.
This article evaluates the efficiency of inserting massive datasets into MySQL using three Java strategies—MyBatis without transactions, direct JDBC with and without transactions, and JDBC batch processing—by measuring execution times for millions of records and analyzing the impact of transactions and batching.
Bilibili’s S12 technical guarantee team coordinated dozens of engineering groups, performed resource estimation, built a shared resource pool, applied chaos engineering, high‑availability architecture, and systematic performance testing to ensure the League of Legends World Championship livestream remained stable and responsive under peak traffic.
This guide explains what performance testing is, why it’s essential, the key metrics such as throughput, response time, and bandwidth, outlines a step‑by‑step testing process, compares load, stress, endurance and capacity testing types, and reviews popular tools like JMeter, LoadRunner and NeoLoad.
This article presents a comprehensive overview of payment system architecture, detailing the core transaction and payment modules, system interactions, service governance, data consistency strategies, asynchronous processing, and practical production practices such as performance testing, stability management, and service isolation.
The author stress‑tested Milvus 2.1.4’s cloud‑native, micro‑service architecture—detailing its write and search paths, evaluating FLAT index performance across 100 K to 10 M 512‑dim vectors, uncovering scaling, scheduler, segment‑rebalance, and upgrade issues, and concluding the system is robust but benefits from graph‑based indexes and Helm‑driven scaling.
This article provides a comprehensive guide on allocating hardware resources, calculating cluster size based on data volume, and conducting index and search benchmark tests for Elasticsearch, offering practical formulas, test configurations, and performance conclusions to help engineers design stable, high‑throughput clusters.
This article explains how Java architects should select appropriate MySQL database machine configurations, collaborate with DBAs for deployment, and conduct essential performance and load testing, covering QPS vs TPS, IOPS, throughput, latency, and other critical metrics for production environments.
This article reviews the practical applications and experimental explorations of StarRocks at 360, describing the cloud‑native lake‑warehouse product Yunzhou, its three‑tier architecture, performance comparisons with Trino using TPCH 100 GB, challenges of Kubernetes integration, and future directions for storage‑compute separation.
This guide outlines practical steps for selecting devices, weighing real devices versus emulators, leveraging cloud and network testing, and conducting UX, performance, and security checks to ensure high‑quality mobile app deployments in today’s fast‑paced digital landscape.
This tutorial explains how to use the open‑source MQTT broker EMQX together with Apache JMeter to create, configure, and run performance tests for IoT platforms, covering installation, test plan creation, and result analysis.
Shopee’s scalable fund‑routing decision engine combines a configurable Go‑based rule engine with Redis‑backed, Lua‑driven quota control to dynamically match loan orders to external capital providers, enforce multi‑dimensional volume limits, achieve tens of thousands TPS, and provide extensible risk‑management capabilities across markets.
This article explains how the Intel istio‑tcpip‑bypass plugin leverages eBPF to bypass the host TCP/IP stack for intra‑node pod communication, provides environment setup, step‑by‑step deployment commands, and shows benchmark results that demonstrate 40‑80% latency reduction and throughput improvement.
This article describes how to efficiently test billions of API parameter combinations by replacing naive nested loops with a queue‑based concurrent approach, dynamically controlling QPS, and addressing memory‑pressure issues using thread‑safe data structures.
This article explains why interface testing is essential for game quality and security, and provides a detailed, step-by-step methodology—including planning, analysis, test case design, execution, result verification, and automation—to help QA teams efficiently test server APIs and prevent player cheating.
This document outlines the background, objectives, scenarios, strategies, TPS estimations, metric definitions, step‑by‑step testing process, component selection, script examples, various execution modes (GUI, CLI, distributed, Docker), and the monitoring architecture built with JMeter, InfluxDB, Prometheus, and Grafana for a large‑scale long‑connection service.
This article presents a detailed performance test of inserting massive data into MySQL with Java, comparing three strategies—MyBatis lightweight insertion without transactions, direct JDBC handling with and without transactions, and JDBC batch processing—showing timing results for millions of rows and offering practical recommendations for high‑throughput data loading.
OpenYurt v1.0, released on September 9, introduces API governance improvements, expanded test coverage with CodeCov, performance testing for Yurthub, streamlined installation, and outlines future enhancements across ControlPlane, DataPlane, and IoT SIGs, with detailed GitHub project links for each.
HiMock is a comprehensive mock platform designed to overcome traditional mock limitations by offering low‑code, code‑decoupled, high‑performance, and full‑scenario support across multiple protocols and front‑end/back‑end channels, enabling efficient testing, performance benchmarking, and parallel development for complex services such as bike, e‑bike, and ride‑hailing.
This article explains Java parallel streams, shows how to replace manual thread handling with a one‑line parallelStream call, benchmarks its performance, discusses cases where it slows down, highlights shared‑variable hazards, and provides practical guidelines for effective use.
This article explains the definitions, objectives, importance, and various types of stability and reliability testing—including stress, recovery, failover, and stability tests—while highlighting how these practices reduce system failures, improve MTBF/MTTR, and support informed decision‑making for software quality assurance.
This technical report details the requirement analysis, environment setup, monitoring tools, load‑test scripts, data design, execution results, and optimization recommendations for stress‑testing ClickHouse and Elasticsearch to ensure they can handle high‑concurrency business peaks.
This article describes the design, hardware and software setup, implementation, testing phases, and performance analysis of a Go‑based backend system that simulates a Spring Festival red‑envelope service capable of handling up to 10 billion requests with peak loads of 60 k QPS per server.
This article explores the QPS threshold required to expose thread‑unsafe operations such as i++ by designing a SpringBoot service, running controlled load tests with both fixed‑thread and precise‑QPS models, and presenting detailed results that show how error rates increase with higher request rates.
This article explains the business‑driven need for regular load‑testing in e‑commerce, outlines the preparation steps, compares onsite, scheduled and hybrid testing approaches, and shares practical results and future plans for achieving efficient, low‑cost, and reliable performance verification.
This article details a comprehensive performance‑testing and optimization effort for a high‑traffic site‑service system, covering hardware setup, CAT monitoring integration, bottleneck identification, Spring Gateway and Netty tuning, asynchronous logging, and the resulting dramatic improvements in QPS and response times.
The article outlines Baidu’s intelligent testing framework, detailing five advanced techniques—contract‑testing‑driven automatic assertion generation, time‑sliced C++ memory‑leak detection via DTW and decision trees, dynamic‑threshold performance diff detection, machine‑translation‑based functional assertion completion, and visual UI diff with and without reference—each boosting accuracy and efficiency in test analysis.
This article explains the design and implementation of a timestamp‑based log replay engine that replays HTTP traffic using Java's DelayQueue, thread pools, and custom data structures, and provides performance test results demonstrating its ability to handle hundreds of thousands of requests per second.
This article provides a comprehensive technical overview of OpenMLDB, covering its overall architecture, online real‑time SQL execution and storage engines, core data structures, pre‑aggregation techniques, and performance test results that demonstrate millisecond‑level latency for feature computation.
This article walks through practical Go implementations of Redis list commands—including LPush, RPush, LLen, LRange, and others—provides unit test examples, demonstrates a simple performance benchmark, and shares a reusable wrapper library for streamlined backend development.
This article explains why pooling costly resources like database connections improves performance, introduces the Commons Pool 2 library and its core classes, demonstrates a Jedis pool with JMH benchmarks showing a 5× throughput boost, and dives into HikariCP's optimizations, configuration tips, and common interview questions.
This article explains why service rate limiting is essential for protecting backend systems from traffic spikes, outlines global, tag‑based and dynamic throttling models, compares common algorithms, shows TSF’s architecture and configuration, and provides practical testing and scaling guidance for high‑traffic e‑commerce scenarios.
This article analyzes the challenges of data‑burst scenarios in a data‑push platform, evaluates traditional throttling methods, presents JVM‑level tuning and a custom heap‑usage based flow‑control mechanism, and validates the solution through extensive pressure testing, demonstrating significant reductions in full GC frequency and overall push latency.
This article presents Ctrip's experience migrating over 2 PB of cold data to JuiceFS, detailing the system's architecture, metadata engine selection, extensive performance testing, fault‑tolerance analysis, and operational optimizations that reduced storage and maintenance costs while supporting future petabyte‑scale workloads.
This article explains what performance testing is, when to conduct it, typical scenarios, step‑by‑step execution—including requirements, test design, tool selection, script examples with Locust, result analysis, and key metrics such as throughput, response time, P90, and optimal concurrency.
This article explains how to combine dynamic and static performance testing models in FunTester by adding asynchronous console commands to control thread‑pool scaling and QPS adjustments, providing step settings, incremental changes, and graceful termination through simple key inputs.
This article examines the implementation of java.util.concurrent.DelayQueue for high‑throughput performance testing, presents a custom Delayed object, shares benchmark code and results across various thread counts, and concludes that DelayQueue can sustain several million QPS when properly tuned.
Bilibili automated full‑link pressure testing for its high‑traffic live‑stream gifting service by adopting traffic co‑location with storage isolation, creating shadow tables, keys and topics, and building a three‑phase, three‑layer framework that analyses links, confirms configurations, and verifies end‑to‑end behavior across all services.
This article presents a comprehensive traffic verification platform that intercepts, records, stores, replays, and load‑tests online request flows to validate functional correctness and performance before cutting traffic to new order‑processing services, offering detailed design, implementation, and practical usage guidance.
This article introduces twelve practical Linux operation tools—including Nethogs, IOZone, IOTop, IPtraf, IFTop, HTop, NMON, MultiTail, Fail2ban, Tmux, Agedu, and NMap—detailing their purpose, installation steps, and usage commands to help system administrators efficiently monitor and secure their servers.
The article examines the MySQL class com.mysql.cj.jdbc.MysqlConnectionPoolDataSource, revealing that despite its name it creates new connections each request and only recycles idle ones, provides a practical Groovy example, highlights pitfalls such as duplicate setURL methods, and concludes it’s unsuitable as a true pool for testing.
To ensure reliable performance‑testing data despite fluctuating ambient temperatures, the team designed and assembled a low‑cost, Arduino‑controlled temperature chamber for mobile devices, detailing the hardware architecture, circuit design, component list, code implementation, and thermal‑insulation optimizations.
Bilibili’s full‑chain load‑testing architecture embeds a unique scenario identifier in every request, propagates it through RPC, databases, caches and async queues, isolates production data via shadow resources, and provides a transparent SDK, link analyzer and mock server, enabling comprehensive testing that uncovered dozens of issues and boosted live‑streaming TPS by 140 % without major code changes.
This article explains the DBLE split feature that partitions large mysqldump files according to sharding configuration, provides command syntax and usage examples, and presents a performance test showing that split‑based import can be up to 18 times faster than direct DBLE import while preserving data correctness.
The article analyzes two common random‑number scenarios in software testing, identifies a CPU‑heavy custom random method, benchmarks ThreadLocalRandom, AtomicInteger, and plain int implementations under multi‑ and single‑thread loads, and proposes a lightweight AtomicInteger‑based selector that consistently delivers the best performance.
This article walks through designing three Redis Stream performance test cases—adding, reading, and add‑delete—using dynamic thread and dynamic QPS models in Java, provides complete Groovy‑based test code, and shows sample console output for evaluating throughput and latency.
This article walks through building a gRPC server and client in Java, then demonstrates four performance‑testing models—static thread, static QPS, dynamic thread, and dynamic QPS—detailing the code, configuration, and execution steps for each, while explaining why the blocking stub is preferred for metric collection.
This article explains how to design and implement a high‑concurrency system for e‑commerce scenarios, covering server architecture, load balancing, database clustering, caching strategies, concurrency testing tools, message‑queue based async processing, first‑level cache, static data handling, layering, distribution, redundancy and automation, with concrete examples such as user sign‑in, order queries and red‑packet distribution.
Bilibili’s senior test engineer Lu Kai built a platformized live broadcast stress‑testing system with five modules—metadata collection, task configuration, pressure generation, performance data collection, and reporting—that reuses thousands of cases, simulates high‑QPS traffic, detects hundreds of bugs and memory leaks, and improves iOS and Android app performance for major events.
A comprehensive catalog of performance testing articles ranging from Linux monitoring tools and test frameworks to concurrency utilities, distributed load testing strategies, QPS modeling and language-specific benchmark studies, providing developers with practical insights and techniques for optimizing system performance.
This article provides a thorough overview of server performance testing, covering fundamental concepts, the influence on users and revenue, key metrics, various test types, a step‑by‑step testing workflow, and a comparative analysis of popular performance testing tools.
The document details Apollo's mobile exception monitoring SDK, explaining its business background, provided capabilities, step‑by‑step workflow, configuration specifications, example rules, performance verification results, and real‑world case studies that demonstrate rapid issue detection and resolution during high‑traffic events.
This article details Bilibili's SRE approach to large‑scale live events, covering background, activity scenarios, resource planning, performance testing, chaos‑engineering drills, technical safeguards such as DCDN, SLB, WAF, PaaS, cache and DB, pre‑plan capabilities, post‑mortem analysis, and future outlook, illustrating how systematic capacity management and automated resilience practices enable stable operation for events with tens of millions of concurrent users.
Learn how to configure Logback in Spring Boot to separate logs by level, implement asynchronous logging for reduced I/O latency, and verify performance gains—up to tenfold throughput improvement—using JMeter tests on a six‑core, 8 GB server, with detailed XML snippets and code explanations.
This guide shows how to download, configure, and run Apache JMeter on a Windows machine to generate 20,000 HTTP requests locally by setting up a thread group, adding an HTTP sampler, and using listeners such as the Aggregate Report to analyze the load‑test results.
This article presents a comprehensive performance testing case study of a multi‑table database query interface, detailing common performance metrics, response‑time classifications, step‑by‑step load‑test results, root‑cause analysis of CPU, memory, and connection‑pool bottlenecks, and demonstrates how tuning Druid’s maxActive and maxWait parameters optimizes throughput and reduces latency.
The article details JD International's technical preparation for the 618 sales event, covering operational planning, DDoS mitigation with Cloudflare, performance testing methodologies, cross‑team collaboration, and real‑time monitoring to ensure system stability and a seamless shopping experience across multiple regions.
This article explains what load testing is, why it matters, the main testing types, essential terminology, compares popular tools, offers step‑by‑step guidance for selecting a tool, and presents detailed real‑world Java performance problem case studies with commands and analysis techniques.
This article details a performance evaluation of Apache Commons Pool2 on a MacBook Pro, comparing no‑wait and wait scenarios, presenting QPS results, identifying bottlenecks in LinkedBlockingDeque and AtomicLong, and outlining the test setup, code, and conclusions.
Web Functions, which support native HTTP/WebSocket protocols, traditionally handle each request with a dedicated instance, but this single‑request concurrency wastes resources and raises costs for I/O‑intensive workloads; enabling multi‑request concurrency—either static or dynamic—consolidates many requests onto fewer instances, cutting latency by up to 80 % and reducing billing by as much as 98.8 %.
Evaluating the Cloud Music online estimation system on NUMA‑based servers revealed that CPU pinning across both memory nodes dramatically boosts throughput on high‑end 96‑core machines—up to 75% for complex models—while low‑end servers gain only modestly, confirming NUMA‑aware scheduling’s critical role for CPU‑intensive inference workloads.
This article explains the importance of conducting full‑link load testing in production environments, outlines the evolution and solution architecture, describes key technologies such as traffic coloring, data isolation and risk control, and shares practical implementation steps and customer case studies from Alibaba.
