How AI‑Powered Dynamic Auditing Transforms Product Review at Dewu

Introduction

Dewu's rapid growth has led to a surge in product listings, making traditional manual review inefficient; the company seeks faster, higher‑quality product onboarding.

AI‑Driven Efficient Auditing

Leveraging recent large‑model advances, the team combines algorithmic capabilities with business rules to build comprehensive, precise audit points, aiming for higher recall and accuracy while reducing manual effort.

Dynamic Configuration Approach

By introducing a dynamic configuration layer, new machine‑audit rules can be added or adjusted without code deployment; configurations are expressed in JSON and interpreted by a rule engine (QLExpress).

Key steps for algorithm integration include defining interface contracts, constructing request parameters from product data, invoking HTTP endpoints, and parsing results.

Audit Process Evolution

The audit workflow has evolved from pure manual checks (human review) to a hybrid model with machine pre‑checks (image quality, duplication, etc.) and AI‑driven evaluations that can automatically reject or modify items.

Current Challenges

Insufficient coverage and adoption of machine‑audit fields.

Configuration is opaque, leading to high iteration cost.

Lack of traceability and data collection for rule execution.

System scalability and development efficiency need improvement.

Process and Design

A backend configuration console allows mapping of application scenarios, business identities, and product dimensions to a reusable rule chain. The chain supports actions such as auto‑approve, auto‑reject, or auto‑modify.

Architecture diagrams illustrate the overall system, business entities, and the machine‑audit execution framework.

Technical Implementation

The rule engine QLExpress is cached for performance; dynamic JSON configurations define field mappings, functions, and conditions. MethodHandle caching accelerates reflection‑based field extraction.

Feign clients provide generic HTTP calls to algorithm services, returning JSON strings parsed into maps for rule evaluation.

/**
 * Cache class field MethodHandle (Key: Class+FieldName, Value: MethodHandle)
 */
private static final Map<String, MethodHandle> FIELD_HANDLE_CACHE = new ConcurrentHashMap<>();

/**
 * Extract field values from object to Map based on config
 */
public Map<String, Object> fieldValueMapping(AutoMachineAlgoRequestConfig requestConfig, Object spuResDTO) {
    AutoMachineAlgoRequestConfig.RequestMappingConfig requestMappingConfig = requestConfig.getRequestMappingConfig();
    Map<String, Object> targetMap = Maps.newHashMap();
    // 1. Simple mapping
    // 2. Complex mapping (basic types)
    // 3. Complex mapping (objects)
    return targetMap;
}

private Object getFieldValue(Object request, String fieldName) throws Throwable {
    String cacheKey = request.getClass().getName() + "#" + fieldName;
    MethodHandle handle = FIELD_HANDLE_CACHE.get(cacheKey);
    return handle != null ? handle.invoke(request) : null;
}

@FeignClient(
        name = "xxx",
        url = "${}"
)
public interface GenericAlgoFeignClient {

    @PostMapping(value = "/{path}")
    String autoMachineAuditAlgo(@PathVariable("path") String path,
                               @RequestBody Object requestBody,
                               @RequestHeader Map<String, String> headers);

    @GetMapping("/{path}")
    String autoMachineAuditAlgoGet(@PathVariable("path") String path,
                                  @RequestParam Map<String, Object> queryParams,
                                  @RequestHeader Map<String, String> headers);
}

{
    "url": "/ai-check/demo1",
    "requestMappingConfig": {
        "fieldMappingList": [
            {"sourceFieldName": "categoryId", "targetKey": "categoryId"},
            {"sourceFieldName": "brandId", "targetKey": "brandId"}
        ],
        "perItemMapping": {
            "mappingFunctionCode": "firstAndFirstGroundPic",
            "fieldMappingList": [
                {"sourceFieldName": "imgId", "targetKey": "imgId"},
                {"sourceFieldName": "imgUrl", "targetKey": "imgUrl"}
            ]
        }
    }
}

Data Analysis & Metric Improvement

After several iterations, audit success rates improved from ~20% to over 50% through algorithm tuning, rule adjustments, and automated actions, with ongoing analysis identifying edge cases for further optimization.