You don’t need to be a coder to make AI work for you. Subscribe to Mindstream and get 200+ proven ideas showing how real people are using ChatGPT, Midjourney, and other tools to earn on the side.

From small wins to full-on ventures, this guide helps you turn AI skills into real results, without the overwhelm.

Get Your Free Guide

In the last episode (check here), we stepped into the lab and asked a deceptively simple question: how do you actually build a quantum computer?

Now it’s time to zoom in on one of the most elegant and promising answers:

Use atoms themselves.

Literally take individual atoms, the fundamental building blocks of matter, and turn them into qubits.

If you strip quantum computing down to its bare essence, you need just one thing:

A system that behaves as a two-level system. A two-level system is something that can exist in exactly two distinct states with one level representing 0 and the other representing 1.

You might wonder—this is exactly what is required for a classical computer as well. However, an additional ingredient is needed: superposition (check episode #12), which allows a quantum computer to exist in superposed states and truly function as a quantum device.

So the question becomes:

Yes.

Atoms.

Atoms are not just tiny particles of matter—they have a very important feature: their energy comes in discrete levels. In other words, an atom cannot have just any energy; it can only take specific values.

A good way to think about this is as a set of steps rather than a smooth ramp. The energy of the atom can sit on one step or another, but never in between.

Now, to build a qubit, we need a system with two well-defined levels. An atom naturally provides this. For example, we can take the lowest energy level (the ground state) and one higher level (an excited state), we can use them as our two states:

Congratulations—you now have a qubit!

But we’re not done. A qubit isn’t useful unless we can:

That’s where light comes in.

To manipulate atoms, physicists use photon—tiny packets of light.

Here’s the key idea:

An atom can act as a qubit, with one energy level as 0 and a higher energy level as 1. But how do we make the atom switch between these two states? The answer is light.

Light is made of tiny packets of energy called photons, and the energy of a photon depends on its color. If a photon has exactly the right energy to match the difference between the two levels, the atom can absorb it and jump from 0 to 1. Later, when the atom releases a photon of the same energy, it falls back from 1 to 0.

By carefully selecting the color of the light, scientists can control the atom with incredible precision—flipping its state, creating superpositions, and performing all the operations needed for quantum computing.

By tuning lasers to exactly the right color (frequency), scientists can:

However, there is one big problem!

Imagine you’re trying to hit something.

Hitting a watermelon? Easy.
A tennis ball? Harder.
A ping-pong ball? Now it’s getting tricky.

Now imagine trying to hit something a million times smaller than a dot.

That’s an atom.

In a quantum computer, we often need to “hit” an atom with a photon to change its state—from 0 to 1. But because atoms are so incredibly small, getting that photon to interact with the atom at just the right moment is extremely difficult. Most photons simply miss.

So how do we improve our chances?

Instead of trying to aim perfectly, we change the game.

We place the atom inside a tiny “box” made of mirrors—an optical cavity—that traps light inside. A photon enters, but instead of flying past once and disappearing, it bounces back and forth over and over again.

The idea is by keeping the photon confined, we dramatically increase the chance that it interacts with the atom.

Inside a cavity:

This is a powerful trick. Instead of relying on perfect aim, we rely on persistence.

So far, we’ve created a single qubit. That’s the quantum equivalent of a lone transistor in 1947—remarkable, but far from transformative. To build a useful quantum computer, we need to scale from one qubit to many, forming a system where qubits can:

Only then can we begin to unlock the real power of quantum computation.

At first glance, it might seem like all the essential ingredients are in place. So what’s holding us back?

The biggest challenge is control.

Atoms are not simple two-level systems—they have many possible energy levels. For a qubit, however, we need to isolate just two of these levels and keep the atom confined there. In reality, even tiny disturbances—such as stray light, thermal fluctuations, or background electromagnetic noise—can push the atom into unwanted states. Photons used to manipulate or measure the system can also be lost or imperfectly detected, introducing further errors.

This sensitivity makes scaling extraordinarily difficult. As the number of qubits increases, so does the complexity of maintaining precise control over each one. And without large-scale systems, quantum computers cannot tackle problems that are truly useful or classically intractable.

Despite these challenges, progress is steady. Researchers have already demonstrated arrays of thousands of neutral atoms—one notable example reaching 6,100 atoms:

While impressive, this is still far from the millions of qubits likely needed for practical, large-scale quantum computing. Bridging that gap remains one of the central challenges in the field, driving ongoing research, new architectures, and innovative approaches to scaling.

Let’s revisit the checklist from the previous episode (check here).

A good qubit must have:

Atoms check many boxes beautifully—but not all of them perfectly. In the next episode, let‘s explore a different type of quantum computer!

Just a couple of days ago, Google Quantum AI announced that, it is now expanding its research to include quantum computers built from neutral atoms — “another promising way to make qubits using individual atoms.”