Zhan Bin
AI Architect / Data Architect
| Item | Details |
|---|---|
| City | Shanghai |
| Language | English - Fluent |
| Interview Availability | Available anytime |
| Notice Period | Available immediately |
| Current Status | Independent project engagement in progress |
WeChat: bin668085 | 76626123@qq.com
GitHub: github.com/bin448482 — Open-source Tarot and RAG project code, analyzable with Claude Code. Concepts such as RAG and Agent are interpreted differently across contexts; the source code is open so that engineering practice can be conveyed directly by code and design trade-offs.
AI Native is how I work — from architectural decisions down to code, AI is a default collaboration partner embedded in every step, not an afterthought tool. In the AI era, the half-life of specific technical skills is shrinking rapidly. What is truly scarce are three capabilities: defining problem boundaries through first-principles thinking (Critical Thinking), designing protocols and orchestration mechanisms that enable heterogeneous capabilities to collaborate efficiently (Harness), and taking Owner-level accountability for end-to-end delivery outcomes (Responsibility).
Engineering definition of Agent and Harness: Calling an LLM API is not the same as building an Agent. An Agent must simultaneously satisfy three requirements — invocable tools (tool execution and environment feedback), an observe-act loop, and termination decided autonomously by the model. All three are mandatory. A system that merely invokes an LLM for a single generation is an LLM application, not an Agent; a fixed-flow DAG built with any framework is still a workflow, not an Agent — the framework itself does not determine whether something is an Agent; only the presence of all three required elements does. Harness is the engineering constraint layer built around these three elements — tool protocols, loop boundaries, termination judgment, state recovery, and audit traceability are extracted from business logic into standalone infrastructure so that Agent behavior becomes observable, constrainable, and regression-testable. The Agent decides "what to do"; the Harness decides "under what constraints and with what observability it gets done."
My experience over the past two years leading an enterprise-grade Agentic AI platform from zero to one embodies this philosophy — going beyond merely calling models or integrating tools, but establishing reusable architectural contracts across Agent identity systems, standardized Skill interfaces, and multi-Agent collaboration patterns; building on this foundation, I further abstracted a general-purpose Pipeline Harness protocol, cleanly decoupling pipeline scheduling from business logic into standalone infrastructure.
I also bring hands-on experience in multinational enterprise data lakehouse architecture and governance, proficiency across the Azure full-stack cloud services and compliant data synchronization solutions, and the ability to independently close the full loop on full-stack projects from requirements analysis to delivery. Holder of the Microsoft Azure Solutions Architect Expert certification.
Development Frameworks & AI Ecosystem: Proficient in Python (LangChain, LangGraph, ChromaDB, Pydantic, FastAPI), C# (.NET Core, Entity Framework). Skilled in TypeScript/JavaScript (React, Next.js, Angular, React Native/Expo), Java (Spring Boot). Familiar with Go.
Data & Cloud Platforms: Proficient in Azure (App Service, Functions, Databricks, Data Factory, SQL Database, Cosmos DB, Storage, Key Vault). Skilled in SQL/Databricks data pipelines and OLAP dimensional modeling. Familiar with Alibaba Cloud DataWorks, MaxCompute, and Data Agent for metadata access, data asset profiling, and controlled execution boundaries. Familiar with Spark, HDFS, Hive.
AI/LLM: Proficient in OpenAI/Azure OpenAI API integration and prompt engineering. Skilled in Agent engineering (engineering implementation of the three required elements — tool invocation with environment feedback, the observe-act loop, and model-decided termination), RAG (Retrieval-Augmented Generation, with vector retrieval and similarity-threshold guardrails), vector databases (ChromaDB), state-graph-based multi-step workflow orchestration (LangGraph), parallel multi-Agent task dispatch and result aggregation, Agent reliability guardrails (retries, timeouts, self-loop prevention, structured output validation), LLM application architecture design, Data Agent Skill design (plan-first execution, evidence chain, human confirmation, SQL approval gates), prompt version management, and A/B experimentation frameworks.
DevOps & Infrastructure: Skilled in Docker, Nginx, CI/CD, Prometheus, Grafana, JSONL log auditing, Azure Key Vault secrets management, JWT authentication, API rate limiting.
Distributed Architecture & Microservices: Skilled in service decomposition and domain boundary delineation, API gateway and unified entry design, asynchronous messaging (message queue decoupling, event-driven architecture), idempotency design and deduplication (unique keys, token deduplication, state machine idempotency), distributed transaction eventual consistency (Saga/TCC/compensation patterns), service registration/discovery and load balancing, configuration centers and dynamic routing, distributed tracing and observability, circuit breaking, degradation, and rate limiting strategies.
Engineering Practices: Proficient in design patterns (Factory, Adapter, modular architecture), configuration-driven development, unit/integration/performance testing, version control and code standards, data lineage tracking and metadata management, data product profiling, physical-to-logical business object mapping, general-purpose Pipeline protocol and task state machine design.
2026.06 – Present richemont AI Data Governance Project
AI / Data Governance Architecture Consultant
Key Responsibilities:
Key Achievements:
2026.01 – 2026.06 Xunao
AI Architect
Key Responsibilities:
Key Achievements:
2023.06 – 2025.09 Zoetis
Data Architect
Key Responsibilities:
Key Achievements:
2016.11 – 2023.02 PWC
Senior Technical Consultant (Solution Architecture)
Key Responsibilities:
Key Achievements:
2010.10 – 2016.10 HP
.NET Developer & Scrum Master
Key Responsibilities:
Key Achievements:
2026.06 – Present Independent Project Engagement
Project Name: Enterprise Data Platform Migration and AI Data Governance Automation (Sanitized)
AI / Data Governance Architecture Consultant
Project Description: Provided AI and data governance architecture support for a large enterprise data platform migration and data asset governance scenario. The project is not a simple field migration. It focuses on identifying metadata differences, model reuse relationships, and downstream impact across source systems, ODS, CDM, and ADS/BI consumption layers, using Data Agent as a controlled governance entry point.
Problems Solved: - Traditional migration analysis often stops at field-name similarity and cannot explain granularity, enumerations, business definitions, business objects, or downstream consumption impact - Sensitive data, production assets, and permission operations must stay inside the client's internal environment, while the personal development environment can only hold methods, templates, scaffolding, and sanitized samples - If Data Agent only produces a readable report, the result is hard to carry forward into SQL validation, quality rule candidates, table tag suggestions, Data Map annotation proposals, and human confirmation workflows
Core Design:
The first layer is dual-path isolation: the client internal path handles DataWorks / MaxCompute / Data Agent execution, while the personal development path handles method design, scaffolding, sanitized sample validation, and output contract iteration. AI only processes metadata, aggregate summaries, SQL drafts, and abstract rules; it does not touch row-level data or production-sensitive information.
The second layer is the three-stage Data Agent Skill protocol: first extract field-level metadata details, then consolidate physical objects into logical business objects using naming patterns, field signatures, lineage, and business keys, and finally generate a structured result package. Each stage has a clear input, output, and responsibility boundary, avoiding a single Agent step that reads, infers, renders, and writes back at the same time.
The third layer is an auditable governance output contract: the result package includes run state, business profile, logical object map, evidence manifest, pending questions, validation SQL drafts, quality rule candidates, tag suggestions, and an optional readable report. SQL is generated as draft by default; aggregate execution and production asset writeback both require human confirmation.
The fourth layer is task-state management: the worklog automation Skill converts scattered records into active / closed / pending confirmation task states, continuously maintaining current phase, progress, risks, blockers, evidence, and next actions, reducing manual context reconstruction when work resumes.
Technical Highlights: - Designed read-only collection paths based on DataWorks OpenAPI / MCP / MaxCompute metadata capabilities, with outputs aligned to metadata difference matrices and downstream impact assessment - Encoded physical-to-logical business object consolidation rules into the Skill contract, requiring header/line, parent/child dimension, process-event, and aggregate views to be expressed at business granularity - Added state files, evidence manifests, pending questions, and SQL approval gates to Data Agent outputs so results can be reviewed, executed, and traced - Used Promptfoo, structured validation, and golden-sample evaluation to check logical object consolidation, report state, safety boundaries, and output fields against regression
Business Value: - Moved early-stage data migration analysis from manual table-by-table interpretation toward a reusable AI-assisted governance method with evidence, confidence, and human confirmation points - Combined DataWorks / MaxCompute metadata capabilities with Data Agent interaction to create a controlled data governance workflow that can run inside the internal environment - Enabled the personal development environment to keep iterating methods, templates, and Skill contracts without carrying out sensitive data, then migrate the refined workflow back for internal validation
Technical Deliverables: - Established Data Agent native data product profiling Skill, table tag suggestion Skill, metadata access scaffolding, data governance profile analysis, and quality assessment workflow - Built sanitized templates for metadata difference matrices, CDM/downstream impact assessments, logical object mapping, validation SQL drafts, and task-state tracking - Developed an SQL-driven field lineage tracing and audit tool with logical path identifiers and branch-aware deduplication to support reproducible generation, change tracking, and regression validation
2026.01 – 2026.06 Xunao
Project Name: Enterprise-Grade Agentic AI Platform
AI Architect
Project Description: Led the overall architecture planning and implementation of a company-level Agentic AI platform. Built a reusable capability foundation around unified entry points, digital employee identity systems, standardized Skill interfaces, and multi-Agent collaboration mechanisms. Delivered a RAG knowledge asset engine and an intelligent candidate evaluation system across operations and recruiting business lines, validating the reuse value of platform capabilities in different business scenarios.
Platform-Level Problems Solved: - When business teams build Agent applications, they tend to duplicate effort on identity definition, capability encapsulation, invocation protocols, and collaboration logic — platform capabilities struggle to accumulate across scenarios - Different business scenarios impose high requirements on data security, execution auditing, result traceability, and localized execution — without a unified governance framework, subsequent expansion costs are high and delivery standards become inconsistent
Platform-Level Approach: The core idea: abstract the recurring common capabilities in Agent development into shared layers — a four-layer architecture managing identity and capability boundaries, standardized Skill interfaces managing capability integration, dual Routers managing scheduling and orchestration. Two business Agents (solution_advisor, candidates) reuse the same contracts on the same platform, validating the "build the foundation once, plug in multiple scenarios" model. Platform-level governance (run manifests, structure validation, traceability verification) ensures every execution result is auditable and reviewable.
Implementation Scenario 1: RAG Knowledge Asset Engine (Operations Business Agent)
Problems Solved: - Solution materials were scattered as fragmented unstructured content; traditional chunking approaches easily lose contextual associations, resulting in noisy retrieval recall, fragmented answers, and difficult traceability - Pre-sales consulting demands high professionalism and consistency — raw materials needed to be transformed into reusable, traceable knowledge assets, rather than relying on manual retrieval of scattered materials
Project Classification and Agent Boundaries: The online Q&A pipeline is a RAG Agent — it has a tool set (Category-first retrieval, Evidence recall, similarity-guardrail validation), an observe-act loop (when retrieval scores fall below threshold, it autonomously rewrites the query or switches categories), and model-decided termination (generate an answer when information is sufficient; otherwise trigger a clarifying question or refuse to answer). The offline Map-Reduce knowledge construction side is intentionally not an Agent — it is a deterministic batch pipeline. Knowledge asset stability comes from determinism; introducing Agent autonomy would amplify noise. The Harness handles guardrails, observability, and traceability validation on the Agent side as engineering responsibilities.
Approach: - Built a Map-Reduce-based knowledge construction paradigm, completing understanding, classification, aggregation, and high-density summarization before ingestion - Designed a three-layer knowledge asset structure — Overview, Category Summary, Evidence — aligned with the cognitive path of “overview → topic → evidence” - Through Category-first retrieval, a Single Source of Truth (SSOT) knowledge asset strategy, and retrieval guardrails, transformed scattered unstructured content into traceable knowledge assets
Technical Highlights: - Moved offline refinement upstream before retrieval, reducing contextual noise during the answer generation phase - Category summaries are bound to original evidence page numbers, enabling answer traceability to specific material locations - Structure validation, traceability verification, and similarity guardrails form a quality gate, ensuring knowledge asset stability
Business Value: - Pre-sales consulting transformed from searching scattered materials to retrieving structured knowledge assets, with consistent external output — Project experience accumulated as reusable knowledge assets, providing a unified knowledge foundation for future operations Agent expansion
Technical Deliverables: - Delivered the solution knowledge engine solution_advisor - Established the Map-Reduce knowledge construction paradigm, three-layer knowledge asset model, and evidence traceability mechanism
Implementation Scenario 2: Intelligent Candidate Evaluation System (Recruiting Business Agent)
The Problem: Resumes arrive from diverse sources and in inconsistent formats. The process from receiving a resume to producing a skill report passes through multiple processing stages. A conventional implementation writes process logic directly into business code — simple to implement, but difficult to resume from breakpoints after interruption, and any change to stage order requires code changes. Human-in-the-loop wait points are treated as exception branches rather than normal pipeline steps.
Project Classification and Agent Boundaries: The project's core positioning is a Pipeline Harness engineering project, not a monolithic Agent. Each stage takes the TaskManifest as its sole input and can run via one of two mutually exclusive execution paths: (1) the in-process LLM path — stages such as jd-resolve, analyze, post-interview, and skill-report invoke LLMs via langchain inside the Python process, producing structured output from a single prompt; this is an LLM application, not an Agent loop. (2) the external Agent path — the Executor Adapter wraps the same task-runner inside Codex, Claude Code, or OpenCode AI CLIs, delegating the work to these external Agents that satisfy all three required elements (tools, observe-act loop, model-decided termination). The Harness's real engineering value lies in letting the same TaskManifest share one set of state boundaries, audit traceability, and regression constraints across both execution modes — "LLM application" and "external Agent" are not differentiated at the protocol layer; they are swappable at the execution layer. Drawing a clear line between "what the Agent does" and "the constraints under which the Harness lets the Agent or LLM application act" is the core of this design.
Core Design:
The system is built on a business-agnostic Pipeline Harness protocol that manages three core states: the task's current stage, the executor identity, and the artifact locations. Six stages (convert→jd-resolve→analyze→await-interview-feedback→post-interview→skill-report) advance in fixed order — stages can be skipped but not executed out of sequence. Abstracting the pipeline as standalone infrastructure requires more upfront design than hardcoding the process directly into business code. The cost is additional protocol-layer design work; the benefit is that scheduling logic is fully decoupled from business scenarios, so the same engine can be reused in other data processing scenarios without modifying the core engine.
Two of these stages are human-in-the-loop waitpoints, implemented with event-driven execution rather than polling: wait state is persisted to the database, with no Worker occupancy and no timeout; human confirmation emits an event to wake the pipeline and continue. Polling is simpler to implement, but it continuously occupies resources and leaves state less reliable. Event-driven execution makes "waiting for human decision" a native semantic of the execution engine, not a conditional branch inside exception handling.
The second design layer is Agents communicating through structured contracts rather than prompt strings. A standard JSON envelope of 18 verbs and 35 structured error codes forms the contract protocol — Agent-to-Agent and frontend-to-backend communication (Pi control surface ↔ Python backend, where Pi is the frontend TypeScript control surface and product-level management interface) all use the same protocol. Natural language is flexible, but it has inherent uncertainty: ambiguity and format drift cannot be programmatically validated by the caller. Structured contracts make every communication machine-verifiable, and fault localization no longer depends on manually interpreting natural-language logs. Natural language is reserved for user-facing output, never as an inter-module communication channel.
External Workers consume a single TaskManifest: no scanning directories, no self-selecting candidates, no self-selecting JDs — the security boundary is physically enforced by architecture, not dependent on behavioral instructions in prompts. After all legacy write paths were retired, a single agent-api bridge remains as the only write path, with the Pi management interface making pipeline state, waitpoints, and regression triggers fully visual.
The third design layer is establishing a regression testing mechanism for AI output at the same level of rigor as code. The supervision model (Facts-first Supervisor + GuidanceBlock) uses a stateless design — it re-aggregates facts fresh from database task rows and JSON files each time, then reasons about the next step from those facts. Cached state can reduce repeated computation, but it makes AI reasoning depend on invisible internal state and weakens post-event reproducibility. Stateless reconstruction adds computation cost, but when facts are unchanged, reasoning remains repeatable and fully supports audit traceability.
The regression framework replays real cases through the full pipeline in an isolated environment. Twelve structured failure codes, ranked by priority, locate the specific assertion that failed — a single pass/fail verdict cannot guide repair direction, while structured failure codes separate "what failed" from "why it failed" and point each regression run to a concrete assertion.
Deliverables:
2023.06 – 2025.09 Zoetis
Project Name: NGSE (Next Generation Sales Engine) Lakehouse & AI Data Engine
Data Architect
Project Description: Led the localization of Zoetis’s global “Next Generation Sales Engine” (NGSE) data infrastructure for the China market. Due to data cross-border transmission regulatory restrictions, the global unified sales engine could not be directly deployed in China, leaving the local sales team without access to unified sales processes and recommendation strategies. The project built a locally compliant lakehouse and AI data engine that adopts global sales methodology within compliance boundaries, forming a sustainably evolving data service foundation.
Problems Solved: - The global unified data and recommendation system could not be directly deployed in China; cross-border transmission restrictions required redesigning core datasets, metric definitions, and model input/output pipelines - Global-local discrepancies in business definitions, master data, and evaluation approaches led to reconciliation difficulties, blocked feature reuse, and high cross-region collaboration costs - The sales engine required continuous, stable data and evaluation inputs, but the existing pipelines struggled to simultaneously satisfy compliance, security, availability, and iteration velocity
Approach: - Differentiated universal data requirements from China-specific needs, then designed the local lakehouse layered architecture and metric definition system accordingly - Data pipelines run from raw business data through to model input/output (raw→feature→label→model layers), handling both batch and near-real-time workloads - The compliance approach centers on data classification rather than blocking transfers: data that can be desensitized or aggregated crosses the border via sync; data dependent on local context is rebuilt domestically. Layered governance allows both paths to run in parallel within the same architecture - Global-local metric discrepancies are managed through a metric and feature mapping system — field dictionary and version management ensure the translation layer remains controlled - Built data service interfaces for algorithm and strategy teams, while optimizing core pipeline compute and storage to ensure stable delivery of critical metrics throughout each sales cycle
Technical Highlights: - Lakehouse layering redesigned under local compliance constraints — each layer (raw retention / feature engineering / model serving / business consumption) is independently defined based on local data characteristics and compliance requirements, rather than copied from the global template - Metric definition mapping and feature mapping run as dual tracks — semantic differences between global and local definitions of the same metric are precisely defined through mapping tables, preventing semantic drift from being amplified in cross-region collaboration - Data reconstruction and cross-border sync coexist within the same architecture — locally-dependent data is rebuilt domestically, data that can be desensitized and aggregated crosses the border compliantly; the two paths are not mutually exclusive - The data pipeline handles both batch and near-real-time modes — sync links and async batch processing operate complementarily, with data freshness matched to scenario requirements within each sales cycle
Business Value: - China's NGSE lakehouse and AI data foundation live in production, global sales methodology adopted in a structured way - Core sales and recommendation data pipelines run reliably, providing dependable input for model training and online recommendations - Global-local metric alignment and feature mapping took effect — cross-region performance evaluation is now based on unified metric definitions - Business teams can track NGSE-driven changes by region and product line, providing a basis for future digital investment
Technical Deliverables: - Established the local lakehouse layered architecture, metric and feature mapping system, compliant cross-border synchronization approach, and data service interface specifications - Built a data governance foundation supporting the co-evolution of recommendation algorithms, sales strategies, and business evaluation
2025.10 – Present Independent Developer
Project Name: Tarot Intelligence Application (TarotAI)
Full-Stack Developer / Independent Developer
Project Description: Independently designed and implemented an AI tarot reading product for anonymous users. Built around a lightweight flow of “select type → write question → draw cards → view reading,” the product encompasses mobile interaction, a two-stage AI reading pipeline, offline content generation tools, and backend operations capabilities, forming a full-stack product architecture that supports continuous iteration.
Design Goals: - Transform tarot reading from a one-shot model call into a configurable, maintainable, and continuously optimizable AI content system - Balance mystique, immersive experience, reading consistency, and response stability in an anonymous usage context - Through productization, bring content generation, experience interaction, and backend operations into a single evolutionary loop - Full-cycle independent decision-making and execution from requirements definition, technology selection, and architecture design through to deployment and delivery, practicing complete product Owner accountability for “end-to-end outcomes”
Project Classification (boundary disclosure): This is not an Agent project. The LLM invocation is a fixed two-stage generation pipeline with no tool-calling loop and no model-decided termination — it is a structured LLM application, not an Agent. It is listed here to provide a complete view of the capability to independently deliver an end-to-end AI product, not to repackage an LLM application as an Agent.
Core Design: - Built an Expo React Native client, FastAPI backend, and Next.js admin console, forming a layered architecture of mobile client, reading service, and operations backend - Designed a four-step divination flow covering both offline and AI divination modes, reinforcing immersive experience through card flip, spread layout, and step progression animations - Offline readings designed as a pre-generated content system: enumerated high-frequency card combinations, interpretation dimensions, and question scenarios, batch-generating structured reading content as a stable content foundation - Online readings designed as a two-stage dynamic generation pipeline — first analyzing interpretable dimensions from user input, then generating personalized readings, reflective guidance, and actionable suggestions based on card combinations and user selections - Built an independent AI generation toolchain, centrally managing prompt templates, language distribution, structured output, and result write-back, enabling mobile and backend to share the same content source
Technical Highlights: - Prompt engineering serves as the core control mechanism, uniformly constraining persona definition, interpretation dimensions, output style, and content boundaries — every AI reading stays consistent and maintainable - Offline pre-generation and online real-time generation run as dual tracks — pre-generated content anchors stability, dynamic generation handles open-ended questions - Anonymous identity, reading history, admin console, and configurable operations together support continuous product evolution — this isn't a one-shot interpretation tool - Client, server, generation tools, and backend connect through modular interfaces and structured output — adding new spreads or reading modes extends without touching the core
Business Value: - AI reading products have the capacity for sustained evolution in anonymous scenarios - Reading capability transformed from real-time generation into a reusable content system — the product is more stable, and subsequent iterations are smoother - Consistency across mobile experience, content production, and backend operations is maintained, supporting continuous tuning and productized operations - Pre-generated content anchors baseline quality, dynamic generation covers open-ended questions — the two paths run independently within the same product architecture, neither blocking the other
Technical Deliverables: - Delivered the TarotAI mobile app, backend operations capability, FastAPI reading service, and AI content generation toolchain - Established the two-stage AI reading pipeline, pre-generated content system, immersive interaction approach, and configurable operations capability
| Date | Institution | Degree & Major |
|---|---|---|
| 1997.09 – 2002.06 | Jiangsu University of Science and Technology | Bachelor, Computer Science & Applications |
| Date | Company | Position |
|---|---|---|
| 2026.06 – Present | Independent Project Engagement (Sanitized Enterprise Data Governance Project) | AI / Data Governance Architecture Consultant |
| 2026.01 – 2026.06 | Xunao | AI Architect |
| 2023.06 – 2025.09 | Zoetis | Data Architect |
| 2016.11 – 2023.02 | PWC | Senior Technical Consultant (Solution Architecture) |
| 2010.10 – 2016.10 | HP | .NET Developer / Scrum Master |
| 2008.10 – 2010.10 | ATA | .NET Developer |
| 2006.02 – 2008.10 | Baodian Info | .NET Developer |
| 2004.11 – 2005.11 | Shanda Network | .NET Developer |
| 2003.06 – 2004.11 | Bus Network Co., Ltd. | .NET Developer |