The origin story

The Android we use today was not the product the founders set out to build. It was not even a phone project for its first year. The pivots, the acquisition and the way the platform was announced all left marks on the governance and the architecture, and those marks are still visible.

TL;DR#

• Android Inc. was founded in October 2003 in Palo Alto by Andy Rubin and Chris White, with Rich Miner and Nick Sears joining.
• The company first worked on an operating system for digital cameras, and pivoted to phones in 2004 after failing to attract investors for the camera idea.
• Google acquired Android Inc. in July 2005, and the platform was announced through the Open Handset Alliance on 5 November 2007, not as a Google product launch.
• The first commercial Android phone was the HTC Dream, sold by T-Mobile as the G1, in September 2008.
• The alliance structure is why "Android" has always been a multi-party project, which is the ancestor of today's AOSP / GMS / vendor split.

Mental model#

Think of a startup as a ship that changes destination while already at sea.

The crew is hired for one voyage, the cargo is loaded for one port, and then the captain discovers the port will not pay. The ship turns. The crew's skills still apply, the cargo can be repurposed, but the hull was designed for the first destination and that shape never fully goes away.

Android's hull is the camera project. The pivots are the turn. And the acquisition is a new owner buying a ship already at sea, with its own crew, its own habits and its own idea of where it is going.

Where the analogy breaks#

A ship has one captain and one destination. Android Inc. had four founders with different roles, and Google did not simply take over the wheel: it kept the team, funded the work, and then built a multi-company alliance around the result. The governance structure that emerged — an open-source project plus a commercial layer plus device-maker partners — is not a thing a single company usually builds for its own product. It is a thing you build when the product was always intended to be bigger than one company.

The big picture#

The timeline starts at the first release because that is when the public record begins. Everything before 2008 is the part that explains why the first release looked the way it did.

Deep dive#

The company before the platform#

Android Inc. was founded in October 2003 in Palo Alto, California. Andy Rubin and Chris White founded it, and Rich Miner and Nick Sears joined shortly after.¹

The first product was not a phone platform. The team worked on an operating system for digital cameras — a camera that would run an OS, connect to a network, and do more than store pictures. The project was called FotoFrame in some accounts. It did not attract the investment it needed, and in April 2004 the company pivoted to building an operating system for phones.¹

That pivot matters for two reasons. First, it explains the platform's early emphasis on software capability over telephony: Android was designed by people thinking about a general-purpose device with a screen, a network and sensors. Second, it explains why the team was small and focused when Google arrived. They had already spent a year discovering that the camera market would not fund them.

The acquisition#

Google acquired Android Inc. in July 2005. The reported price was at least $50 million.¹ The team moved to Google, and the project continued — but now with the resources of a company that could afford a multi-year platform bet.

The acquisition is often told as the moment Android became a Google project. It is more accurate to say it became a funded project with a new owner. The original team stayed, the vision of a general-purpose mobile OS stayed, and the work continued for another two years before anything was announced.

Two years of quiet work is unusual and important. It meant the platform could be designed as a whole rather than assembled from acquisitions, and it meant the first release was a coherent system rather than a bundle of parts.

The alliance announcement#

On 5 November 2007, the Open Handset Alliance announced Android. The alliance included Google, handset makers, carriers and chipset manufacturers.¹

The structure was deliberate. A phone platform only succeeds if device makers ship it and carriers sell it, and neither group would adopt a platform controlled entirely by a potential competitor. Announcing through an alliance — with an open-source project at its centre — was the governance move that made adoption possible.

It also set the pattern that still exists:

That table is the direct descendant of the 2007 decision. The names changed and the modularity got much more sophisticated, but the three-party structure was set at the announcement.

Why the camera story is not just trivia#

The camera origin explains a design instinct that persisted. A camera OS has to handle a sensor, a screen, storage, a battery and a network, with a UI that is mostly a viewfinder and a shutter. That is a general-purpose device profile, and it is much closer to a phone than to a feature phone's address book.

It also explains why the early platform invested in media and graphics out of proportion to its market: the team had been building for a device whose whole purpose was capturing and viewing images. The emphasis on a capable graphics stack and a real media pipeline was not a later strategic decision; it was the founding use case.

The first device#

The HTC Dream, sold by T-Mobile as the G1, launched in September 2008 running Android 1.0.¹ It had a slide-out keyboard and a trackball, both of which look strange now and both of which were reasonable for a device whose main competitors had physical keyboards.

The first release already contained the pieces that define the platform: the four application components, the notification shade, a home screen with widgets, and an app store. It also contained Dalvik, the runtime that would be replaced by ART six years later.

The four years, condensed#

A timeline makes the sequence easier to hold:

Five events over five years. The gaps are as informative as the events: two years of quiet work between the acquisition and the announcement, and ten months between the announcement and the first device. Both gaps are the kind of thing a startup cannot afford and an acquirer can.

What the origin explains#

Four things about modern Android are easier to understand with the origin in mind.

Why the platform is general-purpose. It was designed by people who wanted a computer with a screen and a network, not a phone with apps. The emphasis on sensors, graphics and a managed runtime follows.

Why the governance is multi-party. The alliance was the only way to get adoption. That is why AOSP is open, why GMS exists as a separate licensed layer, and why the vendor interface had to be formalised later.

Why compatibility is enforced by documents and tests. A multi-party platform needs a shared definition of "Android". The CDD and CTS are that definition, and they exist because the platform was never going to be controlled by one company's release process.

Why the early releases look experimental. The first few years were a small team iterating on a new product category. The design eras — pre-Holo, Holo, Material — are the visible trace of that iteration.

How it evolved#

The early architecture rows show a platform being assembled: Dalvik, the core libraries, the framework. The pattern that emerges by Android 5.0 — a runtime replacement, then a modularity project — is the platform growing up.

Under the hood#

• ‹›Activity.java↗the Activity class from the original four components, still the centre of the app model
• ‹›Application.java↗the Application object that every process created from Zygote constructs
• ‹›Build.java↗the version constants that trace back to the first release

Curiosity corner#

• The camera pivot is real. The founders worked on a camera OS before phones, and the switch happened in 2004.
• The acquisition price was at least $50 million. Small by later standards, enormous for a two-year-old company with no shipped product.
• The alliance announced the platform, not Google alone. That structure is why "Android" was never a single-company product in the way iOS is.

Try it#

$ adb shell getprop ro.build.version.release
adb shell getprop ro.build.version.sdk
adb shell getprop ro.build.fingerprint

Illustrative output — values differ per device.

Build it#

B01 — Hello lifecycle is a direct descendant of the app model the first release shipped: an Activity, a layout, and a lifecycle.

Check yourself#

Sources#