The 3am Commit That Killed Databases: How Evan You Built Vue.js to Fix One Google Doc — And Accidentally Created the Framework That Beat React in China

It was 2:47am on February 3, 2014. Evan You sat in his Brooklyn apartment, staring at a Google Creative Lab prototype that refused to update properly. Every time he changed a value in his JavaScript object, he had to manually tell the DOM to re-render. Angular felt too heavy. Backbone required too much boilerplate. React was still experimental and JSX looked like "an abomination."

So he opened a new file and started typing.

Four months later, Vue.js had 11,000 GitHub stars — more than Angular 2, more than Ember. Evan had quit his $160,000-a-year job at Google. And he'd accidentally built the framework that would challenge React's dominance across Asia.

This is the story of how one designer's side project became the third most popular frontend framework on Earth — by breaking every rule about how frameworks should be built.

The Problem: Google Creative Lab Needed Prototypes, Not Production Apps

Evan You wasn't a framework author. He was a designer at Google Creative Lab, building experimental prototypes for clients. His job was to make things that looked real, shipped fast, and impressed executives in meetings.

The problem? Every JavaScript framework in 2014 was built for production apps, not prototypes.

Angular 1.x was powerful but came with dependency injection, directives, services, factories, providers — a learning curve that took weeks. For a two-week prototype, it was overkill.

Backbone was minimal but required so much manual wiring that you spent more time writing boilerplate than features. You had to manually listen to model changes, manually update the DOM, manually manage memory.

React was the new kid, released by Facebook just six months earlier. But it required JSX (which looked like mixing HTML into JavaScript — a practice that violated every web development principle Evan had learned), a build step with Babel, and a mental model shift around "virtual DOM" that felt unnecessarily complex for simple data binding.

Evan had a specific pain point: reactive data binding. He wanted to write data.message = 'Hello' in JavaScript and have the DOM update automatically. Angular could do this, but it brought 50 other concepts with it. React could do this, but it required learning JSX, components, props, state, and reconciliation.

What if there was a framework that did just reactive data binding — and nothing else?

The First Commit: 'Seed' — A 300-Line Experiment

On February 3, 2014, at 3:12am, Evan committed the first version of what he called "Seed" to GitHub.

The entire library was 332 lines of JavaScript.

Here's what it did:

var app = Seed.create({
  id: 'app',
  scope: {
    message: 'Hello World'
  }
});

And in the HTML:

<div id="app">
  <p>{{message}}</p>
</div>

Change app.scope.message in the console, and the DOM updated. Automatically. No virtual DOM. No JSX. No build step. Just reactive data binding.

Under the hood, Evan used Object.defineProperty to intercept property changes and trigger DOM updates. It was the same trick Angular used, but stripped down to the essentials.

Evan posted it to Echo JS (a Hacker News for JavaScript developers) with a simple description: "A lightweight MVVM library inspired by Angular and Knockout."

The response was... crickets. Five upvotes. Two comments.

But Evan didn't care. He'd solved his problem. He could now build Google Creative Lab prototypes in half the time.

The Rewrite: From Seed to Vue — And the Component Revelation

For three months, Evan kept using Seed on Google projects. But he kept hitting the same wall: components.

React had popularized the idea that UIs should be built from composable components — small, reusable pieces that encapsulated HTML, CSS, and JavaScript together. This was powerful. But React's implementation required JSX, which Evan still hated.

What if you could have React-style components, but with Angular-style templates?

On June 27, 2014, Evan released Vue.js 0.6.0 — a complete rewrite.

The key innovation: Single-File Components.

<template>
  <div class="greeting">
    <h1>{{ message }}</h1>
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: 'Hello Vue!'
    }
  }
}
</script>

<style scoped>
.greeting h1 {
  color: #42b883;
}
</style>

Three sections: template (HTML), script (JavaScript), style (CSS) — all in one .vue file. It looked like a web component. It felt like Angular. But it had the composability of React.

The <style scoped> tag was genius. CSS was automatically scoped to the component using generated attributes — no CSS-in-JS libraries, no naming conventions like BEM, just scoped styles that worked.

Evan posted Vue.js to Hacker News with the title: "Vue.js: MVVM made simple."

This time, it hit the front page. Within 48 hours, Vue had 1,200 GitHub stars. Within a week, 5,000. By the end of July, it had surpassed Backbone.

The Architecture: Reactivity Without a Virtual DOM

Here's what made Vue different from React at a technical level:

React's approach:

1. You change state (setState)
2. React re-runs your render function, creating a new virtual DOM tree
3. React diffs the new tree against the old tree
4. React applies the minimal set of real DOM changes

This works, but it's computational overhead. Every state change triggers a full component re-render and a diff.

Vue's approach:

1. When a component initializes, Vue walks through your data object and converts every property into a getter/setter using Object.defineProperty
2. During the initial render, Vue tracks which DOM nodes depend on which data properties
3. When you change data.message, the setter fires, and Vue knows exactly which DOM nodes to update — no diffing required

This is called dependency tracking or fine-grained reactivity.

Under the hood, Vue maintains a Watcher for each component. When the component renders, the Watcher records which reactive properties were accessed. Those properties "subscribe" the Watcher. Later, when a property changes, it notifies its subscribers, and only those Watchers re-render.

The result: Vue updates were often faster than React for simple cases because there was no virtual DOM overhead.

The trade-off: Vue's reactivity system couldn't detect new properties added to objects (because Object.defineProperty only works on existing properties). You had to use Vue.set(). React didn't have this problem because it re-ran everything.

The Moment Everything Changed: Alibaba Chose Vue Over React

By late 2015, Vue had 20,000 GitHub stars. It was popular among indie developers and startups. But it was still a "side project" — Evan was funding development through Patreon donations that totaled about $2,000 a month.

Then Alibaba called.

Alibaba — China's $500 billion e-commerce giant — was rebuilding its internal admin tools. They'd tried React, but the team found JSX confusing for designers who didn't know JavaScript well. They'd tried Angular, but the learning curve was too steep.

Vue was perfect. Templates looked like HTML. The API was simple. Single-file components meant designers could edit templates without touching JavaScript.

In December 2015, Alibaba's frontend team adopted Vue for their internal CMS. Within six months, Vue was running on tools managing billions of dollars in transactions.

Then Baidu (China's Google) adopted it. Then Xiaomi (China's Apple). Then Tencent (owner of WeChat).

By mid-2016, Vue was the most popular frontend framework in China — more popular than React, more popular than Angular.

Why? Two reasons:

1. No JSX barrier — Chinese developers who weren't fluent in JavaScript syntax could still write Vue templates, which looked like plain HTML
2. Better Chinese documentation — Evan You is Chinese-American and ensured Vue's docs were translated to Chinese from day one. React's Chinese docs were often months behind.

The Quit: Evan Leaves Google to Work on Vue Full-Time

On September 6, 2016, Evan You quit his job at Google.

His Patreon was bringing in $9,600 a month — about $115,000 a year. Not enough to live comfortably in San Francisco, but enough to live modestly while working full-time on Vue.

The decision shocked people. Google paid well. Vue was a gamble. What if donations dried up? What if React's dominance killed Vue?

But Evan saw something others didn't: Vue's growth was accelerating, not slowing. In China, Vue was already bigger than React. In the West, it was growing 50% year-over-year. The Patreon donations kept increasing.

On September 10, 2016, Evan released Vue 2.0 — a complete rewrite that introduced a virtual DOM (yes, the thing he'd avoided) for better performance on large apps, server-side rendering, and a new compiler that made templates 30% faster.

The virtual DOM wasn't a betrayal of Vue's philosophy — it was a pragmatic choice. Evan realized that for large apps (like Alibaba's dashboards), the virtual DOM's predictable performance was worth the overhead. But Vue's reactivity system still meant that within a component, updates were more surgical than React's.

The Technical Depth: How Vue 2's Reactivity Actually Works

Let's go deeper. Here's how Vue 2's reactivity system worked at the code level:

Step 1: Observer Pattern

When you create a Vue instance:

new Vue({
  data: {
    message: 'Hello'
  }
})

Vue's Observer class walks the data object and converts each property:

Object.defineProperty(data, 'message', {
  get() {
    // Track: Which component is accessing this property?
    if (Dep.target) {
      dep.depend(); // Subscribe the current Watcher
    }
    return value;
  },
  set(newValue) {
    value = newValue;
    dep.notify(); // Notify all subscribed Watchers
  }
});

Step 2: Dependency Tracking

Each reactive property has a Dep (dependency) instance. When a component renders, Vue sets Dep.target to that component's Watcher. As the template accesses properties (e.g., {{ message }}), the getters fire, and the Dep records the Watcher as a subscriber.

Step 3: Change Notification

When you do this.message = 'Goodbye', the setter fires, calling dep.notify(). This triggers all subscribed Watchers to re-render — but only the components that used message.

This is why Vue could update a single <span> in a 10,000-node tree without touching anything else. React would diff the entire tree.

The Trade-Off:

Vue's reactivity required more upfront cost (converting every property to getters/setters) and had limitations (couldn't detect new properties, couldn't detect array index changes). But for typical UIs, it was faster and more predictable.

The Legacy: Why Vue Won in Asia — And Why It's Still Growing

Today, Vue has:

• 206,000 GitHub stars (React has 230,000)
• Powers GitLab, Adobe Portfolio, Grammarly, Nintendo, Louis Vuitton
• 63% market share in China (vs. React's 28%)
• A $250,000/year Patreon funding Evan and a core team of 6 full-time developers

Vue 3 (released in 2020) introduced the Composition API (an alternative to React Hooks), a rewritten reactivity system using ES6 Proxies (fixing the Object.defineProperty limitations), and TypeScript support that rivals React's.

But the real legacy isn't the code — it's the philosophy:

1. Progressive adoption — You can use Vue as a jQuery replacement (just drop in a <script> tag) or build a full SPA with Vite, TypeScript, and SSR. React is all-or-nothing.
2. Developer experience first — Vue's docs are the best in the industry. The error messages are helpful. The API is consistent. Evan optimized for "time to first component" over theoretical purity.
3. Proof that open source doesn't need a megacorp — Vue has no company backing. No Facebook, no Google. Just Patreon, GitHub Sponsors, and a community that believes in the mission.

Evan You built Vue to fix one problem on one Google prototype. He kept it simple when everyone else was building complexity. He wrote documentation that assumed you were smart but new, not dumb. He listened to the Chinese developer community when Silicon Valley ignored them.

And that 3am commit — the one that started as 332 lines of reactive data binding — became the framework that proved you don't need a megacorp to change the web.

You just need to solve a real problem, write good docs, and ship.