I’ve been baking bread a lot lately, and there’s one instruction that comes up over and over again: mix up your dough, cover it, and leave it alone for an hour or two while it rises. The problem is that hour or two is really just an estimate. How quickly the dough grows depends on the recipe, temperature, your yeast or starter, and plenty of other variables, so when the timer goes off the dough might be ready, it might need more time, or it might have been ready quite a while ago.

That’s what I built this Proof Monitor to help with. It uses a distance sensor mounted above the dough to watch how much the dough rises, along with a temperature and humidity sensor and an ESP32. The ESP32 keeps track of what I’m baking, what stage of the recipe I’m on, how much the dough has risen, and when I need to come back and check it. It can also send notifications to my phone, so I don’t have to keep checking the dashboard or setting multiple timers.

There are two ways to build it. The Basic DIY version uses the two sensor boards soldered together into one compact assembly and connects them to the ESP32 with Dupont wires. The PCB version uses a custom carrier board that holds the ESP32 and both sensors in fixed positions. Both versions require some soldering, and both run exactly the same software once they’re finished.

The complete source code, browser installer, wiring information, PCB files, and other project files are available on GitHub:

https://github.com/Canterrain/bread-proof-monitor

Electronics

You need:

1. ELEGOO ESP32 development boards:https://amzn.to/46aN2Hq (affiliate)
2. HiLetgo SHT31-D temperature and humidity sensor: https://amzn.to/4xLTMYm (affiliate)
3. VL53L0X time-of-flight distance sensor:https://amzn.to/4xEbyg1 (affiliate)
4. USB-C data cable: https://amzn.to/4gJS7uQ (affiliate)
5. Soldering iron: https://amzn.to/47aOiKZ (affiliate)

For the Basic DIY Build you will also need:

1. Male 2.54 mm header pins for the sensors
2. Hookup wire or jumper wire
3. Soldering iron
4. Solder
5. Hot Glue
6. A rubber grommet

For the PCB Build you will also need:

1. Bread Proof Monitor Rev A carrier PCB
2. Soldering iron
3. Solder
4. recommended: double sided sticky tape, thin

Container

I developed mine around a round 4 QT Cambro container, but the important part is not the brand.

You need a container where:

1. the distance sensor can point straight down at the dough,
2. the lid or sensor support can remain in a repeatable position,
3. and there is enough distance between the sensor and dough for the dough to rise without touching it.

The monitor measures one point on the dough surface, not the total volume of the dough. A fairly level dough surface gives it the best target.

The main sensor is a VL53L0X time-of-flight distance sensor. It mounts above the dough and measures the distance between the sensor and the surface below it. As the dough rises, that distance gets smaller.

Before starting a proof, the monitor first measures the distance to the bottom of the empty container. After the dough is added, it takes another measurement to establish the starting dough height. From there, the ESP32 can compare new distance readings with the starting measurement and calculate how much the dough height has increased.

The second sensor is an SHT31, which measures temperature and humidity. Temperature in particular can have a noticeable effect on proofing time, so having that information alongside the rise measurement makes the dashboard more useful and also lets the firmware adjust some of its timing behavior.

There are a couple of things to keep in mind with this approach. The distance sensor measures one point on the top of the dough, so this is not calculating the total volume of the dough. I try to position the sensor reasonably close to the center of the container and start with a relatively even dough surface.

The other important consideration is stability. The monitor cannot tell the difference between the dough moving closer to the sensor and the sensor moving closer to the dough. Whichever version you build, keeping the sensor in a fixed position is an important part of getting useful measurements

Both versions of the Proof Monitor require soldering, but the sensors are assembled differently depending on which version you are building.

Basic DIY Version

For the Basic DIY version, the VL53L0X and SHT31 are soldered together using the same set of header pins. The black plastic spacer on the header strip sits between the two boards and helps hold them apart, leaving you with one compact sensor assembly instead of two separate boards.

Before soldering, line up the matching connections on the sensors: VIN or VCC, GND, SDA, and SCL. Pay close attention to how the two boards are oriented. The VL53L0X needs to point down toward the dough once everything is installed, and its sensing area needs to remain unobstructed. Make sure the second sensor board and the black plastic spacer do not block it.

I recommend soldering one pin first, checking that both boards are positioned correctly and sitting straight, and then soldering the remaining pins. Once you finish, the two sensor boards should form one rigid unit.

From there, connect the combined sensor assembly to the ESP32 with four female Dupont wires. Connect 3V3 on the ESP32 to VIN or VCC on the sensor assembly, GND to GND, GPIO22 to SDA, and GPIO21 to SCL.

For this project, GPIO22 is SDA and GPIO21 is SCL. That differs from the default assignment you may see in some ESP32 examples, so follow the labels on your actual sensor boards and double-check the connections before powering anything on.

PCB Version

For the PCB version, each sensor gets its own normal set of 2.54 mm male header pins. Solder one strip to the VL53L0X and another to the SHT31, making sure the pins stay straight so they will slide cleanly into the sockets on the carrier board. Be sure to have the sensors facing away from the long side of the pins so they don't end up ponting at the PCB instead of the dough.

A breadboard or spare female header socket can help keep everything aligned while soldering. As with the Basic version, soldering one pin first gives you a chance to check the alignment and make adjustments before soldering the rest.

The PCB handles the shared power and I²C connections, so the sensors do not need to be wired together manually.

The Basic DIY and PCB versions use different methods to mount the sensors, so follow the section for the version you are building.

Basic DIY Version

For the Basic version, drill one hole through the lid large enough for the four Dupont wires to pass through. Install a rubber grommet in the hole, then feed the wires through so the ESP32 can remain on top of the lid while the sensor assembly sits underneath.

Connect the Dupont wires to the sensor assembly and double-check the wiring before securing anything permanently. Once you know the connections are correct, I recommend adding a small amount of hot glue around the Dupont connector housings where they meet the sensor pins. This helps keep the connections from working loose and gives the sensor assembly some additional support.

Next, position the black Dupont connector housings against the underside of the rubber grommet and hot glue them to the grommet. The goal is to make the sensor assembly rigid rather than leaving it hanging freely from the wires. It should not swing, rotate, or move up and down as you handle the lid.

Before the glue fully sets, check the VL53L0X again and make sure it points straight down with nothing blocking the sensing area. Once everything has cooled, gently move the lid around and confirm that the sensor assembly stays in the same position.

PCB Version

The PCB version needs two openings in the lid so the sensor sockets on the underside of the carrier board can pass through.

I recommend starting by placing the PCB against the top of the lid in the position where you want it mounted. Try to place it so the distance sensor will be as close to the center of the container as practical. Once the board is positioned, trace around the two socket sections that need to pass through the lid.

Remove the PCB and cut those openings. A drill press gives you good control, but you can also carefully use a box cutter or another suitable tool if that is what you have available. Test-fit the board as you go and enlarge the openings only as much as necessary.

The PCB should slide into place from the top side of the lid, with the sensor sockets passing through and the sensors themselves ending up underneath. The ESP32 remains above the lid.

I included mounting holes on the PCB, but for this version I recommend using strong double-sided adhesive tape instead. That avoids putting additional holes through the lid and keeps the installation simple. It also means the PCB version does not need hot glue around the sensors underneath the lid, which gives it a cleaner finished installation.

Once the board is secured, make sure it cannot shift and confirm that the VL53L0X has a clear view straight down into the container.

Step 4: Assemble the PCB Version

If you are building the Basic DIY version, you can skip this step.

Start by plugging the ESP32 into the two sockets on the top of the carrier board. Then plug the VL53L0X distance sensor and the SHT31 temperature and humidity sensor into their matching sockets underneath.

The important part is making sure all three modules are facing the correct direction before you power anything on. These connectors are not keyed, so it is possible to install a board backward or offset by a pin. Use the markings on the PCB and the labels on each module to confirm the orientation.

Once the ESP32 and both sensors are seated correctly, the PCB assembly is finished.

You do not need Arduino IDE to install the Proof Monitor software. The project has a browser-based installer that can flash the ESP32 over USB.

Connect the ESP32 to your computer using a USB data cable and open:

https://canterrain.github.io/bread-proof-monitor/

Use a supported desktop browser, click Connect, choose the ESP32, and select Install. On the first installation, choose the option to erase the device before installing. Once the firmware finishes, the ESP32 will restart.

The first time it boots, the Proof Monitor creates a Wi-Fi network named:

ProofMonitor-Setup

The password is:

sourdough

Connect your phone or computer to that network and open:

http://192.168.4.1

Choose your normal home Wi-Fi network, enter the password, and save the settings. After the ESP32 restarts, reconnect your phone or computer to your usual Wi-Fi and open:

http://proofmonitor.local

If that address does not work on your network, you can also find the ESP32’s IP address in your router and open that directly.

The dashboard is hosted on the ESP32 itself, so there is no separate account or cloud service required to use the monitor on your local network.

Optional Phone Notifications

The Proof Monitor can also send notifications through ntfy. During setup it generates a random ntfy topic that you can subscribe to using the ntfy app.

Once subscribed, use the test notification option on the Proof Monitor to make sure everything is working. Keep the generated topic private because anyone who knows it can subscribe to it or send messages through it.

Notifications can let you know when a fold is due, when the bulk rise is ready to check, or when a final proof has reached its target. The dashboard works locally without ntfy, but notifications require internet access.

Open the dashboard and select Choose Your Bake. The Proof Monitor includes different profiles because the amount of rise you are looking for depends on the recipe and on which stage of the recipe you are monitoring.

For example, a recipe may need a larger rise during bulk fermentation and a much smaller rise after shaping. Other recipes include stretch-and-folds during bulk, while some move the dough into a different container for final proof. The profiles let the monitor keep track of those differences without requiring you to remember a separate target every time.

Choose the recipe and whether you are monitoring the Bulk or Final stage. Each included profile also links back to the recipe it was based on so you can continue following the actual baking instructions alongside the monitor.

With the container empty and the lid in its normal position, press Set Empty Setup. The monitor takes several valid distance measurements and uses them to establish the bottom of the container.

Remove the lid, add the dough, and smooth the top enough to give the distance sensor a consistent surface to measure. Put the lid back in the same position, allow everything to settle, and press Set Starting Dough Height.

At that point the monitor has everything it needs to begin tracking the proof. The dashboard shows the current rise percentage, elapsed time, temperature, humidity, target, recipe, stage, and whatever step is coming next.

Some breads need to be handled during the proof, and removing the lid changes the distance measurement. The Proof Monitor has a pause and resume system for that.

If a stretch-and-fold is due, press Pause Monitoring before removing the lid. Perform the fold, replace the lid in its normal position, and press Resume Monitoring. After the reading has had time to settle, press Complete Step.

The monitor starts a new measurement segment after the fold while keeping the progress from the earlier part of the proof. That lets it continue tracking the overall rise without treating the reshaped dough as though the proof started over.

Recipes that change containers need another calibration. Detroit-style pizza is a good example because the bulk rise happens in one container and the final proof happens in the pizza pan. Once the dough moves, the original empty measurement no longer applies, so the monitor prompts you to establish a new empty setup and starting height for the final stage.

For wider pans, I also made a set of legs that can support the monitor above the dough instead of relying on a matching lid. The same basic rule applies: keep the sensor in a fixed position and recalibrate when the physical setup changes.

There is also a Re-baseline After Lid Off option under Advanced for times when you remove or reposition the lid outside the normal workflow. Pause the monitor, put the lid back into position, resume, allow the readings to settle, and then re-baseline. That preserves the progress already recorded while establishing a new reference point for the current sensor position.

When the target is reached, the monitor can send a notification and the dashboard will indicate that the proof is ready to check. I still treat that as a prompt to inspect the dough rather than an automatic decision that the proof is finished.

There are too many variables in bread for one distance sensor to make that decision by itself. Look at the dough, touch it, and use the cues from the recipe. If you are happy with where it is, press Finish Proof.

If the recipe has another monitored stage, the Proof Monitor prepares that stage next. Otherwise, continue with the linked recipe for whatever comes after proofing.

The suggested targets included with the monitor are also meant to be starting points rather than fixed numbers. Different flour, hydration, yeast, starter strength, and kitchen temperatures can all change what works best.

After a proof, you can tell the monitor whether the dough was Underproofed, Just Right, or Overproofed. Feedback is stored separately for each recipe and stage. If you repeatedly mark a stage as underproofed, the monitor gradually raises its suggested target. If you repeatedly mark it as overproofed, it gradually lowers the target.

The changes happen in small steps and are limited so one unusual batch cannot drastically change a profile. The goal is simply to let the suggested targets adapt over time to what actually works in your kitchen.

The Basic DIY version and PCB version both run the same software and provide the same core features. The main difference is how much work goes into the physical assembly and how repeatable the sensor mounting is.

The Basic version is the easiest way to build the project without ordering a custom circuit board, and it was the version I used while developing most of the software. The PCB version makes the sensor placement more rigid, removes the hand-wired connections between the ESP32 and sensors, and gives the finished monitor a cleaner installation on the lid.

Once everything is set up, the Proof Monitor can track dough rise, temperature, humidity, recipe-specific proofing targets, folds, bulk and final proof stages, and optional phone notifications. It also gives you a way to adjust those targets over time based on how your own dough responds.

All of the code, wiring information, browser installer, PCB design files, manufacturing files, and current documentation are available on GitHub:

https://github.com/Canterrain/bread-proof-monitor

If you build one, I’d be interested to hear what you make with it and how well the included targets work in a different kitchen. The project was designed around the idea that those targets are useful starting points, but the final decision about whether the dough is ready still belongs to the person making the bread.