一物一码全链路闭环：小程序扫码溯源 + 中台数据存储 + 物联网终端上报完整架构设计

The Pain Point of Traceability: It’s Not Just “Sticking a Code”

FreshStory is a premium fresh food chain brand, built on the promise of “from farm to table” quality. But they faced a very real problem: consumers didn’t believe them.

You say your beef is imported from Australia — what’s the proof? You say your vegetables are organically grown — how do you prove it? If there’s a food safety issue, can you trace which batch it came from and where it originated?

Many companies’ approach: stick a QR code on the product, consumers scan it and see some information. But look closely, and these so-called “traceability codes” have many problems:

• Static information: Scanning shows a picture of the origin + some text description — pre-recorded, unrelated to the actual batch.
• Broken data chain: You only see origin information; transportation, warehousing, and store stages are all black boxes.
• Easily copied: Anyone can scan the QR code, anyone can copy it. Counterfeit products stick the same code — consumers can’t tell the difference.
• No closed loop: They scan and that’s it. The company doesn’t know who scanned it, when, or what feedback consumers have.

Frankly, many traceability systems are just “window dressing” — giving consumers psychological comfort, but useless when real problems arise.

So what should a real “one item, one code” traceability system look like? The solution we built for FreshStory centers on four words: end-to-end closed loop.

Overall Architecture: One Chain, Three Terminals

The system architecture can be summarized as “one data chain, three terminal entry points”:

┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐
│Origin/   │  │Warehouse/│  │Store     │  │Consumer  │
│Factory   │  │Logistics │  │Terminal  │  │          │
│Code &    │  │Scan &    │  │In/Out    │  │Scan &    │
│Report    │  │Transfer  │  │Bound     │  │Query     │
└─────┬────┘  └─────┬────┘  └─────┬────┘  └─────┬────┘
      │             │             │             │
      └─────────────┴──────┬──────┴─────────────┘
                           │
                    ┌──────┴──────┐
                    │ Biz Middle  │
                    │ Platform    │
                    │Code Service/│
                    │Storage/     │
                    │Analytics    │
                    └─────────────┘

One data chain: Every product’s journey from creation to consumption is recorded at each stage, forming a complete data chain.

Three terminal entry points:

• Production side: Origin/factory assigns codes, records product base information.
• Flow side: Warehousing, logistics, store stages scan codes, record transfer status.
• Consumer side: Consumers scan to query, and consumer behavior data flows back to the company.

Let’s break down this architecture layer by layer, starting with the “code” itself.

Layer 1: Code Design — It’s Not Just a QR Code

Many people think “one item, one code” is just generating a QR code and sticking it on. It’s not that simple. Code design directly determines the security and usability of the entire system.

1. Code Type: Dynamic vs. Static

A static code has fixed content — scanning it always shows the same page. The problem: easily copied. Counterfeit products stick the same code and you can’t tell the difference.

We use dynamic codes: each code’s content is dynamically generated, and the first scan looks different from subsequent scans.

Specifically:

• Each code has a unique ID, bound to the product.
• First scan by a consumer shows a “First Query” marker, with query time and location.
• Second scan shows “This is the Nth query” and lists all previous query records.

This way, if a consumer buys a product and scanning shows “already queried 5 times,” they should be careful — it might be counterfeit.

2. Code Security: Anti-Forgery, Anti-Tampering

How do you prevent code forgery? We use several layers:

• Encrypted generation: Code IDs aren’t sequential numbers — they’re encrypted random strings that can’t be guessed or batch-forged.
• Backend verification: Every scan requests backend verification — code validity, cancellation status, query count — all determined by the backend.
• Physical anti-counterfeiting: For high-value products, combine with anti-counterfeit labels (e.g., scratch-off, laser hologram). The QR code is printed under the anti-counterfeit layer — you scratch to scan, and once scanned, it’s invalidated.

3. Code Hierarchy: Case Code + Box Code + Item Code

Fresh food has a characteristic: batch management matters. A case contains 10 boxes, a box contains 20 items. If every single item needs a code, costs are too high.

Our solution is a three-level code system:

• Case code: One code on the outer carton, representing the whole case — used in logistics and warehousing.
• Box code: One code per box, representing a box — used for store receiving and sales.
• Item code: High-value items (e.g., imported steak, organic vegetables) get individual codes for detailed traceability.

The three levels are linked: scan a case code and see how many boxes are inside and what each box’s code is. Scan a box code and see which case it belongs to and where it came from. This ensures traceability while controlling costs.

Layer 2: Data Collection — Every Stage “Speaks”

With codes in place, the next step is collecting data at each stage, recording the product’s entire “lifetime.”

1. Production/Procurement Stage: Code Assignment + Base Info

At the origin or factory, codes are assigned when products are produced, and base information is entered:

• Origin info: which farm, which batch, when harvested/produced.
• Quality info: grade, specifications, weight.
• Inspection info: pesticide residue reports, quality inspection reports (images or PDFs can be uploaded).
• Responsible person: who’s in charge of this batch.

This step can be done with PDA handheld terminals, or with a mini program — workers scan with their phones and enter data, no specialized equipment needed.

2. Warehousing & Logistics Stage: Scan + Transfer Records

As products move from origin to warehouse, from warehouse to store, each transfer is scanned and recorded:

• Inbound: Scan case code, record inbound time, warehouse location, quantity.
• Outbound: Scan case code, record outbound time, destination store, carrier.
• Transport: For temperature-controlled goods (e.g., cold chain), temperature sensors in the truck automatically report temperature data, bound to the transport record.

One technical detail: logistics stages don’t always have network access. For example, during long-haul transport, drivers on highways have no signal. So our PDAs and mini program both support offline operation — store locally first, sync when network is available. The middle platform uses idempotent processing to ensure no duplicate data.

3. Store Stage: Receiving + Sales + After-Sales

At the store, there are more stages:

• Receiving: Scan case/box code, confirm receipt, record time, receiver, temperature at receipt (for cold chain goods).
• Shelving: Moving from backroom to shelf — scan to record shelving time.
• Sales: POS system integrates with the middle platform — when sold, automatically records sale time, store, price.
• Spoilage: Expired or damaged products — scan for spoilage report, record reason.

Some data is entered by manual scanning, some synced automatically by systems. The key: every stage’s data is bound to that unique code.

4. Consumer Stage: Scan + Behavior Data

Finally, consumers buy the product and scan to see traceability info. This step isn’t just “showing information to consumers” — it’s the final link in the data closed loop: sending consumer behavior data back.

When consumers scan, we capture:

• Who scanned (WeChat openid, anonymized).
• When they scanned.
• Where they scanned (geolocation).
• What information they viewed, how long.
• Whether they clicked “contact customer service,” “report issue,” etc.

This data is extremely valuable:

• Anti-counterfeiting verification: If the same code is scanned many times in scattered locations, it’s likely counterfeit.
• Consumer insights: Which origin info do consumers care about most? Which products have the highest scan rates?
• Precision marketing: Consumers who scanned can receive relevant coupons or membership benefits.

Layer 3: Middle Platform Data Storage — Handling Massive Data

A “one item, one code” system generates a lot of data. Suppose FreshStory sells 100,000 items daily, each item goes through an average of 5 stages, each stage generates 1 record — that’s 500,000 records per day, nearly 200 million per year.

With that much data, how do you store it? How do you query it?

Our storage architecture looks like this:

┌─────────────────────────────────────────┐
│         Access Layer: API Gateway       │
├─────────────────────────────────────────┤
│         Service Layer: Code Service     │
│   Generate/Verify/Query/Link/Stats      │
├──────────┬──────────┬──────────────────┤
│Relational│Time-Series│   Object Storage │
│  DB      │  DB      │  (Reports/Images)│
│PostgreSQL│ TDengine │    S3/MinIO      │
└──────────┴──────────┴──────────────────┘

1. Relational Database: Base Information

Product base information (name, specs, origin, batch, etc.) lives in a relational database. This data volume isn’t large, but queries are frequent, and transactional consistency is needed.

2. Time-Series Database: Flow Records

Scan records from each stage, sensor-reported data — these are all time-series data: timestamped, high volume, write-heavy read-light, queried by time range.

This data goes into a time-series database (we use TDengine). Time-series databases are optimized for this scenario: fast writes, high compression ratio, good query performance.

3. Object Storage: Files

Inspection reports, origin photos, videos — these files go into object storage. The database only stores the file URL; fetch when needed.

4. Query Optimization: Pre-Aggregation + Caching

When consumers scan to query, they need the entire chain’s data. If you query multiple databases in real-time every time, it’s slow.

Our approach:

• Pre-aggregation: After a product is sold, the backend asynchronously aggregates the entire chain’s data into a query table.
• Caching: Traceability info for popular products lives in Redis cache. Scanning retrieves directly from cache — millisecond response.

This gives consumers a great scanning experience — no waiting.

Layer 4: Data Closed Loop — From “Queryable” to “Useful”

Many traceability systems stop at “consumers can scan and see information.” But we believe that’s just the beginning. The real value lies in the data closed loop — data isn’t just queryable, it can be used for analysis, decision-making, and marketing.

1. Anti-Counterfeiting & Anti-Fraud

Through scan data, you can spot anomalies:

• The same code queried multiple times in a short period, in scattered locations.
• Query locations don’t match the product’s sales region (e.g., a Beijing product’s code scanned in Guangdong).
• Abnormally high scan rates for a batch (normal might be 5%, suddenly 50% — could be a problem).

When anomalies are detected, automatic alerts trigger, and the marketing team can investigate.

2. Supply Chain Optimization

With end-to-end data, you can analyze supply chain efficiency:

• What’s the average time at each stage? Which stage is the bottleneck?
• How often do temperature excursions happen during transport? Which carrier is the problem?
• What’s the store spoilage rate? What causes it?

Find the bottlenecks, optimize accordingly. After FreshStory launched the system, data analysis revealed higher temperature excursion rates on one route. After switching carriers, spoilage dropped 15%.

3. Consumer Operations

Consumers who scan are real people who bought your product — a very precise user group.

You can:

• Guide them to follow your official account, register as members.
• Recommend related products based on what they bought.
• Run scan-to-win raffles, points programs, to boost repurchase.
• Collect consumer feedback to improve products and service.

After launch, members registered via scanning had 3x higher conversion rate than other channels — because consumers just bought your product, they trust you, and conversion is best at that moment.

Results: More Than Just Traceability

Six months after FreshStory’s “one item, one code” system launched:

• Consumer trust improved: Products with traceability codes sold 20%+ more than those without.
• Spoilage rate dropped: Through supply chain data analysis, several bottlenecks were identified, and overall spoilage dropped 12%.
• Member growth: Over 100,000 members registered via scanning, repurchase rate up 15%.
• Food safety assurance: Once, a batch of vegetables tested positive for pesticide residues. Using the system, they identified affected stores and products within two hours and pulled everything — no food safety incident occurred.

Closing Thoughts

“One item, one code” sounds like a simple concept — isn’t it just sticking a code on a product? But doing it right, achieving an “end-to-end closed loop,” involves many layers.

From secure code design, to data collection at every stage, to storing and querying massive data, to analyzing and applying the data — every layer has technical details, every layer has business value.

Traceability isn’t the goal. Building trust through traceability, optimizing the supply chain, connecting with consumers — that’s where the real value lies.

If you’re considering a “one item, one code” system, don’t just think “stick a code so people can query it.” Think bigger: can the data form a closed loop? What can you do with that closed loop? Figure those out, and your investment will pay off much more.