DEV Community: Vincent

“I Like It Very Much”: Why We Built MandarinClips

Vincent — Mon, 19 Oct 2026 08:45:12 +0000

1. The Moment My Brain Froze for Five Seconds

A few years ago, on my first overseas business trip, I walked up to a local bank teller to withdraw cash. What followed was an excruciating linguistic freeze that remains etched into my memory.

I had studied English in China for well over a decade. I aced standardized tests and assumed routine daily interactions would be effortless.

After processing my paperwork, the teller looked up, smiled, and asked:

“How do you like your money?”

I froze. A sudden ringing filled my ears. Instinctively, I blurted out: “Pardon?”

Assuming I hadn't heard clearly, she slowed down and enunciated every syllable:

“How... do you like your money?”

My brain shut down completely for five agonizing seconds: “Do I like my money? What kind of philosophical question is this? Does anyone on earth dislike their own money?”

Under her expectant gaze, I panicked and forced out an answer that deserves a place in the hall of shame:

“I... I like it very much!”

The air in the room instantly turned to stone. Holding back a smirk, she gently explained what she actually meant: “What denominations would you prefer? Hundreds, twenties, or small bills?”

I walked out of that bank drenched in cold sweat. That absurd exchange shattered my confidence: we spend years memorizing thousands of lexical items and grammatical paradigms in sterile ivory towers, yet the moment we step into native reality, our very first sentence reduces us to square one.

2. "Sterilized Chinese" vs. The Living World

When we look at Chinese language education, international learners face the exact same farce.

Open almost any standard beginner-to-intermediate textbook, and the dialogue inevitably reads like this:

“你好，你去不去食堂？” (Hello, are you going to the cafeteria?)

“我不去食堂，我去图书馆。” (I am not going to the cafeteria; I am going to the library.)

Syntactically immaculate. Lexically pristine. Utterly lifeless.

In an actual Chinese office, apartment complex, or dinner table, native speakers almost never communicate like this.

A real interaction looks more like:

“中午一起吃个便饭？” (Grab a quick lunch together?)

“改天吧，今天手头实在有点紧。” (Another day—my hands are completely tied today.)

Or:

“我还是算了吧，你们去。” (I'd rather pass—you guys go ahead.)

Native speakers rarely fling a blunt, chilling “我不去” (I am not going) into someone's face. We deploy “改天吧” (another day) to preserve face; we use “算了吧” (let's drop it) to lower expectations; we lean on “老实说” (honestly speaking) to pivot toward candid pushback; and we drop “别提了” (don't get me started) to cut off a frustrating tangent.

These discourse markers, pragmatic softeners, and micro-tonal hesitations constitute the living soul of actual communication. To standardize instruction, conventional curricula filter out these vibrant pragmatic nuances, leaving behind nothing but a hollow, sterilized syntactic skeleton.

3. My Sister’s Desk and the "Lesson Prep Torment"

If learners are suffering through artificial language, teachers on the other side of the podium endure an entirely different kind of torture.

My sister is a university English professor, and my brother-in-law is a university lecturer as well. To outsiders, academia looks pristine and comfortable. But whenever I looked at her desk late at night, I saw the endless, manual exhaustion that went into crafting engaging lessons.

To bring a classroom to life and demonstrate how an expression actually functions in authentic contexts, she needed film dialogue snippets.

Yet locating a single, five-second usable video clip required:

Digging through mental archives to remember which show or film featured that exact phrase;
Opening a media player and scrubbing the timeline back and forth blindly across two hours of video;
Once found, manually screen-recording, exporting audio, transcribing dialogue, and double-checking context.

Sourcing three authentic, high-quality examples routinely burned two to three hours of her evening.

Watching her drag media scrubbers frame by frame late at night for tomorrow's slide deck, it hit me:

Whether teaching English or Chinese, language educators everywhere are bogged down by grueling manual material collection, while learners are starved for living language.

Why not engineer an industrial solution to eliminate this friction entirely?

4. Building MandarinClips: Grounding Language in Empirical Context

As a software engineer accustomed to building high-throughput systems, my immediate intuition was clear: this shouldn't be an endless manual sinkhole. It is a structured corpus engineering problem.

If we could segment every conversational turn across classic cinema into atomic audiovisual units, and index them across Pragmatic Function (How to say), Syntactic Frames (How to construct), and Social Scenarios (When to say), the landscape changes:

For Educators: Preparing a module on pragmatic softeners or colloquial '把' variations no longer takes hours. Enter a keyword, and within three seconds retrieve 50 authentic clips equipped with precise timestamps, source attribution, preceding conversational turns, and aligned translations. Lesson prep shrinks from hours to seconds.
For Learners: No more "I like it very much" linguistic paralysis. Search an expression and witness real human beings navigating hesitation, nuance, irony, and warmth on screen, instantly grasping the pragmatic subtext.

This realization forms the bedrock of MandarinClips.

5. A Living Discovery Map, Not a Video Platform

Today, MandarinClips indexes over 180,000 real-world cinema dialogue snippets.

We skipped social feeds, gamified flashcard streaks, and disruptive autoplay loops. We focused entirely on building an intuitive, deterministic discovery map for spoken Chinese:

Expression Index (/expressions): Discover how native speakers convey reluctance, validation, dismissal, and casual rapport.
Grammar Index (/grammar): Observe how core syntactic frames naturally compress, invert, and omit elements in spontaneous speech.
Scene Index (/scenes): Master social distance and interpersonal boundaries across workplace requests, family conflicts, and social banter.

Language lives in the messy, nuanced reality of human interaction. MandarinClips exists to lift the burden of lesson prep off tired teachers, and to help dedicated learners finally understand the unspoken subtext behind what native speakers say.

I Built an Open-Source SEO Indexing Infrastructure with Rust

Vincent — Fri, 28 Aug 2026 02:37:38 +0000

A website being online does not mean search engines understand it

As developers, we usually think:

If my website is deployed and users can access it, the job is done.

But after building content-heavy websites, I realized there is another layer that developers often overlook:

How do search engines discover, crawl, and understand my website?

After deployment, many invisible problems can appear:

Are pages returning the correct HTTP status codes?
Is the sitemap valid?
Are URLs structured correctly?
Are there unexpected 404 pages?
Are search engines still crawling the website?
Which URLs are indexed and which are not?

These problems usually do not appear during local development.

They only appear after your website is live.

The problem I experienced

While building my own content website, I encountered unexpected indexing issues.

At first, everything seemed fine.

The website was running.
The pages were accessible.
The application worked.

However, search engine crawling behavior changed after some deployment and website structure changes.

Lesson 1: Infrastructure stability affects search engine crawling

The website was initially deployed on Cloudflare Workers.

Because of runtime limitations, some requests occasionally resulted in 5xx errors.

For normal users, an occasional failure may only be a small inconvenience.

But for search engines, repeated failures can affect how they evaluate a website.

A website that frequently fails to respond correctly is harder for search engines to crawl reliably.

Eventually, I noticed that search engine crawling activity decreased significantly.

This made me realize:

Website reliability is not only a user experience problem. It is also a search engine visibility problem.

Lesson 2: URL changes are more dangerous than they look

Later, I changed parts of my URL structure to make it cleaner and more SEO-friendly.

However, changing URLs is not just a simple string replacement.

It affects:

redirects
sitemap generation
URL discovery
indexing status
search engine understanding

Without proper monitoring, it is difficult to know whether these changes are helping or hurting.

SEO starts before keywords

When people talk about SEO, they often think about:

keyword research
ranking optimization
backlinks
content strategy

These are important.

But for developers, there is a more fundamental question:

Can search engines correctly access and understand my website?

Before optimizing keywords, we should make sure:

pages are accessible
URLs can be discovered
technical SEO issues are detected
website structure is healthy

Building IndexFlow

This experience led me to build IndexFlow-core.

IndexFlow-core is an open-source search engine indexing infrastructure designed for developers.

The goal is not to replace SEO professionals.

Instead, it focuses on the technical foundation between websites and search engines.

Current focus areas:

Sitemap management
URL discovery
SEO quality checks
Indexing workflow management
Search engine submission infrastructure

GitHub:

https://github.com/IndexFlowing/IndexFlow-core

Website:

https://www.indexflowing.com

Why Rust?

I wanted IndexFlow to be:

lightweight
self-hostable
reliable
suitable for long-running services

Rust fits this kind of infrastructure project very well.

During development, I also extracted some reusable components into standalone Rust libraries.

The idea is simple:

If a component can be useful outside IndexFlow, it should not be locked inside the project.

Open-source direction

IndexFlow-core is moving toward an open-source search engine indexing infrastructure.

The long-term vision is to provide developers with better tools for managing the relationship between their websites and search engines.

Future improvements include:

better SEO quality gates
smarter URL scheduling
multi-site management
improved indexing monitoring

Final thoughts

IndexFlow was not created because I wanted to build another SEO tool.

It started because I encountered a real problem while building websites.

Deployment issues, URL changes, and indexing problems made me realize:

Search engine visibility also needs infrastructure.

That is why I started building IndexFlow.

If you are interested in technical SEO, Rust, or open-source infrastructure, I would love to hear your feedback.

Thanks for reading.

How I built a high-performance Chinese learning platform with 100k+ TV clips using Rust and Next.js 15

Vincent — Mon, 20 Jul 2026 02:44:30 +0000

Hi dev.to community! 👋

Today, I’m incredibly excited to share MandarinClips, a side project I’ve been pouring my soul into. It's a high-performance language learning platform that indexes and organizes sentence-sized dialogue segments from authentic Chinese movies and TV series to help language learners transition from sterile textbooks to real-world immersion.

👉 Check it out here: MandarinClips.com

Here is a deep dive into the engineering decisions, performance bottlenecks, and the technical architecture that powers the platform under the hood.

🏗️ The High-Level Architecture

I wanted the platform to be blindingly fast, cost-effective, and highly available. Here is the stack:

Frontend: Next.js 15 (React 19) + Tailwind CSS + next-intl (for multilingual support).
Backend: Rust (Axum framework) + Tokio async runtime.
Database: PostgreSQL with pg_trgm (trigram) extension.
Storage & CDN: Backblaze B2 proxied through Cloudflare CDN (S3 API compatible, 0-cost egress).

⚡ Backend: Why Rust & Axum?

The backend is responsible for high-frequency search requests, serving sitemaps, and tracking user quota usage.

Using Rust was a no-brainer for several reasons:

Safety & Zero-Cost Abstractions: No garbage collection means zero GC pauses, resulting in extremely predictable latency.
Axum & Tokio: Axum is a highly ergonomic, thin routing wrapper on top of Tokio. It handles asynchronous tasks with minimal CPU overhead, allowing our single 2-core VPS to handle thousands of concurrent queries without breaking a sweat.

🗄️ Database: Sub-millisecond Fuzzy Search with PG GIN Indexes

With over 100,000 video clips and subtitles indexed, a standard ILIKE '%query%' search would quickly degrade and result in full table scans, locking up the CPU under high traffic.

To solve this, we utilized the PostgreSQL pg_trgm (trigram) extension to build GIN (Generalized Inverted Index) on both Chinese characters and no-tone pinyin strings.

CREATE EXTENSION IF NOT EXISTS pg_trgm;

CREATE INDEX idx_clips_text_zh_trgm 
ON clips USING GIN (text_zh gin_trgm_ops);

CREATE INDEX idx_clips_pinyin_search_trgm 
ON clips USING GIN (pinyin_search gin_trgm_ops);

By querying against these indices, fuzzy matches for queries like "ni hao" or "明天见" take under 1 millisecond locally. We achieve pure O(1) list scans.
🎥 Media Delivery: 0-Cost Egress with Backblaze B2 & Cloudflare
Hosting over 100,000 MP4 video clips can quickly become a bandwidth billing nightmare on standard cloud providers.
We solved this by storing all .mp4 video files and .jpg posters in Backblaze B2, which is part of the Cloudflare Bandwidth Alliance. By proxying the B2 bucket through Cloudflare's global edge network:
All public egress bandwidth is $0.
We configured aggressive Cloudflare Cache Rules (using Cache-Control: public, max-age=86400, s-maxage=604800 headers) so that sitemaps and video assets are served straight from Cloudflare's edge memory, dropping origin VPS bandwidth and IOPS to near-zero.
🌐 Frontend: Next.js 15 & Native 308 Permanent Redirections
For the frontend, we used Next.js 15. One of our recent refactoring milestones was migrating legacy URLs from underscores (_) to SEO-friendly dashes (-).
To preserve SEO link juice, we avoided heavy JS-based Edge middleware and leveraged Next.js's native redirects config in next.config.ts to issue 308 Permanent Redirects at the router level:
// next.config.ts
async redirects() {
return [
{
source: '/sitemap.xml',
destination: 'https://www.mandarinclips.com/sitemaps/sitemap.xml',
permanent: true,
}
];
}
This is processed natively before any middleware execution, ensuring zero-latency transitions for Googlebot.
🎁 Wrapping Up & Feedback
Building MandarinClips has been an incredible full-stack journey.
I’d love to hear your feedback on the architecture, the Rust Axum setup, or the database indexing! If you're currently learning Chinese (or are just curious about the UI), please check out MandarinClips and let me know your thoughts in the comments below!
Happy hacking! 🚀