DEV Community: Yoshida.T

Visualize Temperature & Humidity with Raspberry Pi Pico W DHT11 — Build an IoT Prototype with Miniviz

Yoshida.T — Sat, 21 Mar 2026 04:35:56 +0000

Visualize Temperature & Humidity with Raspberry Pi Pico W × DHT11 — Build an IoT Prototype with Miniviz

Japanese: devto_pico_temphumi.ja.md

This guide walks through reading temperature and humidity with a Raspberry Pi Pico W and a DHT11, sending the data to Miniviz, and visualizing it.

It’s a solid setup for IoT prototypes, hobby electronics, and learning.

What is Miniviz?
What you’ll build
What you need
Wiring the Pico and DHT11
- Pinout
Reading sensor data
- Set up VS Code and MicroPython
- Install the Pico firmware
- Sample read script
Sending data to Miniviz
- Get your project ID and token
- Source code to send to Miniviz
Viewing data in Miniviz
Creating a chart
Wrap-up
Pro plan beta / monitor program
Tags

What is Miniviz?

Miniviz is a service for easily storing, visualizing, and notifying on IoT data and images.

It fits prototypes (PoC), hobby projects, and education.

Miniviz - IoT Data Visualization & Graphing Platform

What you’ll build

You’ll use a Raspberry Pi Pico W and a DHT11 temperature/humidity sensor to collect readings and visualize them in Miniviz.

What you need

Raspberry Pi Pico W (referred to as “Pico” below)
DHT11 temperature/humidity sensor
Breadboard and jumper wires
MicroPython environment
Miniviz project ID and API token

Wiring the Pico and DHT11

Wire it as shown in the photo.

Image: wiring photo

Pinout

Pico pin	DHT11	Role
`36`	`VCC`	Power
`20` (`GP15`)	`DATA`	Signal
`38`	`GND`	Ground

Image: yellow VCC, blue GND, green GP15

Reading sensor data

Set up VS Code and MicroPython

This walkthrough uses the MicroPython workflow in VS Code.

Install the MicroPico extension — it helps manage talking to the Pico and transferring code.
Run MicroPico: Configure project from the Command Palette (Ctrl+Shift+P) This creates Pico-specific completion and connection settings in your folder.

Image: extension UI

Image: bottom status bar / MicroPico controls

Install the Pico firmware

Download the correct UF2 file for your board (Pico or Pico W) from the official site.
Hold the BOOTSEL button on the board while plugging in USB.
When the Pico appears as a USB drive, copy the UF2 onto it.
It will reboot automatically; you’re ready.

MicroPython on Raspberry Pi Pico

Sample read script

Once your environment works, run this sample.

The onboard LED blinks on each successful read.

from machine import Pin
import dht
import time

led = Pin("LED", Pin.OUT)

# DHT11 connected to GPIO 15
sensor = dht.DHT11(Pin(15))

print("Starting measurements...")

while True:
    try:
        # Trigger measurement
        sensor.measure()

        # Get values
        temperature = sensor.temperature()
        humidity = sensor.humidity()

        print(f"Temperature: {temperature}°C, Humidity: {humidity}%")

        # Blink onboard LED on success
        led.on()
        time.sleep(0.1)
        led.off()

    except OSError as e:
        print("Failed to read sensor. Check wiring!")

    # Wait for 2 seconds (DHT11 requirement)
    time.sleep(2)

You should see temperature and humidity in the console.

Image: output after clicking Run

Sending data to Miniviz

Get your project ID and token

Extend the script with Wi-Fi, time sync (NTP), and HTTP so you can POST to Miniviz.

Create a project in Miniviz and copy the project ID and API token.

See the quick reference for details.

Image: project ID and token screen

Source code to send to Miniviz

Replace Wi-Fi credentials, project ID, and token with your own.

import network
import urequests
import time
import machine
import dht
import ntptime

# ================= Configuration =================
WIFI_SSID  = "YOUR_WIFI_SSID"       # Wi-Fi SSID
WIFI_PASS  = "YOUR_WIFI_PASSWORD"   # Wi-Fi Password
PROJECT_ID = "YOUR_PROJECT_ID"      # Miniviz Project ID
TOKEN      = "YOUR_TOKEN"           # Miniviz API Token
LABEL_KEY  = "PicoW_DHT"            # Label for the device
SEND_INTERVAL = 120                 # Interval between sends (seconds)
# =================================================

# Hardware Setup
dht_sensor = dht.DHT11(machine.Pin(15))
try:
    led = machine.Pin("LED", machine.Pin.OUT)
except ValueError:
    led = machine.Pin(25, machine.Pin.OUT)

def connect_wifi():
    """Connect to Wi-Fi and sync time via NTP"""
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(WIFI_SSID, WIFI_PASS)

    print(f"Connecting to {WIFI_SSID}...", end="")
    while not wlan.isconnected():
        led.toggle()
        time.sleep(0.5)

    print("\n✅ Wi-Fi Connected!")
    led.off()

    # Attempt time synchronization using NTP
    ntptime.host = "ntp.nict.jp"
    try:
        print("Syncing time via NTP...", end="")
        ntptime.settime()
        print(" Done!")
    except:
        print(" Failed (Using internal clock)")

def send_data_to_miniviz(temp, hum):
    """Send measurement data to Miniviz and log details"""
    url = f"https://api.miniviz.net/api/project/{PROJECT_ID}?token={TOKEN}"

    # Calculate UNIX timestamp in milliseconds
    # Assuming time.time() is synced to 1970 Epoch
    unix_time_sec = time.time()
    ts_ms = int(unix_time_sec * 1000)

    # Create Miniviz-compliant payload
    payload = {
        "timestamp": ts_ms,
        "label_key": LABEL_KEY,
        "payload": {
            "temperature": temp,
            "humidity": hum
        }
    }

    print("\n" + "=" * 40)
    print("📡 Data Packet Prepared")
    print(f"  [Timestamp] {ts_ms}")
    print(f"  [Label]     {LABEL_KEY}")
    print(f"  [Metrics]   Temp: {temp}°C, Humidity: {hum}%")
    print("-" * 40)

    try:
        print("🚀 Sending request to Miniviz...", end="")
        res = urequests.post(url, json=payload)

        if res.status_code in [200, 201]:
            print(f"\n✅ Success! (Status: {res.status_code})")
            print(f"  Response: {res.text}")
            # Blink LED twice on successful transmission
            for _ in range(2):
                led.on()
                time.sleep(0.1)
                led.off()
                time.sleep(0.1)
        else:
            print(f"\n❌ Server Error (Status: {res.status_code})")
            print(f"  Reason: {res.text}")

        res.close()
    except Exception as e:
        print(f"\n⚠️ Network/Connection Error: {e}")
    print("=" * 40)

def main():
    connect_wifi()

    print("\nStarting Telemetry (Ctrl+C to stop)")

    while True:
        try:
            # Read from sensor
            dht_sensor.measure()
            t = dht_sensor.temperature()
            h = dht_sensor.humidity()

            # Send data
            send_data_to_miniviz(t, h)

        except OSError as e:
            print(f"❌ Sensor Read Error: {e}")

        # Wait for the next interval
        time.sleep(SEND_INTERVAL)

if __name__ == "__main__":
    main()

You should see send logs in the console.

Image: log on successful send

Viewing data in Miniviz

Open the Database section to inspect incoming points.

It may take on the order of ~30 seconds to show up.

Image: Database view

Creating a chart

Use Viz → create a chart.

This example uses a line chart.

Image: chart setup

Image: resulting line chart

Wrap-up

You used a Raspberry Pi Pico to stream temperature and humidity into Miniviz with minimal setup.

Miniviz also supports many other sensor payloads and images — give it a try.

Pro plan beta / monitor program

We’re looking for people to try the Pro plan and share feedback. Individuals, students, and companies who can use it for a while and report back may receive Pro access for a limited time — contact us or DM for details.

There’s also a 14-day free trial. Pro lifts limits and adds image workflows — worth a look.

Miniviz - IoT Data Visualization & Graphing Platform

Build a Simple Raspberry Pi Snapshot Monitor with a USB Camera

Yoshida.T — Mon, 08 Dec 2025 02:05:37 +0000

What is Miniviz?

Miniviz is a service that allows you to easily store, visualize, and receive alerts for IoT data and images.
It is well-suited for PoC projects and learning purposes.

In this guide, we’ll build a simple surveillance-camera-like system using a Raspberry Pi and a USB camera.

https://miniviz.net

Part #1 (Monitoring temperature and humidity with ESP32):
https://dev.to/yoshidataisei/how-to-send-esp32-sensor-data-to-miniviz-for-real-time-visualizationminiviz-1-59na

What we will do

We will connect a Raspberry Pi to a USB camera and send images to Miniviz.

:::note info
Image upload is available only with the Pro plan.
:::

What you need

Raspberry Pi
Using VS Code Remote SSH is convenient
USB camera
Miniviz Project ID and Token

Connecting the Raspberry Pi and USB Camera

Connect the USB camera and run the lsusb command.

pi@raspberrypi:~ $ lsusb
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 002: ID 0424:2514 Microchip Technology, Inc. (formerly SMSC) USB 2.0 Hub
Bus 001 Device 003: ID 0424:2514 Microchip Technology, Inc. (formerly SMSC) USB 2.0 Hub
Bus 001 Device 004: ID 0424:7800 Microchip Technology, Inc. (formerly SMSC)
Bus 001 Device 007: ID 0411:02da BUFFALO INC. (formerly MelCo., Inc.) USB 2.0 Camera // これがUSBカメラ

You can check the USB camera device file.

$ ls /dev/video*
/dev/video0  /dev/video10  /dev/video12  /dev/video14  /dev/video16  /dev/video20  /dev/video22  /dev/video31
/dev/video1  /dev/video11  /dev/video13  /dev/video15  /dev/video18  /dev/video21  /dev/video23

Checking the image captured by the camera

$ sudo apt-get install fswebcam
$ fswebcam -r 640x480 --no-banner image.jpg

The image quality isn’t great, but it works.
(Open the image via GUI or download it locally using scp, etc.)

(((Yes… my room is really cold…)))

Sending camera images to Miniviz

Overall steps:

Obtain your Project ID and Token
Call the Image API and try sending a sample image
If it works, send actual camera images using the API

1. Obtain your Project ID and Token

Get your Project ID and Token from the Miniviz dashboard.
Create a project → then retrieve the Project ID and Token.

2. Call the Image API to send a sample image

First, try sending the sample image you captured earlier.
API: Send an image in the request body

POST https://api.miniviz.net/api/project/{project_id}/image?token={token}

Request body

{
    "timestamp": 1717587812345,
    "label_key": "raspberry_pi_cam",
    "image_name": "camera.jpg",
    "image_base64": "base64_encoded_image_data"
}

Sending a sample image (Python)

#!/usr/bin/env python3
"""
figure image to miniviz
"""
import requests
import base64
import os
from datetime import datetime, timezone

# Settings
PROJECT_ID = "PROJECT_ID"
TOKEN = "TOKEN"
API_URL = "https://api.miniviz.net"
IMAGE_PATH = "image.jpg" # The captured image, or any sample image
LABEL_KEY = "raspberry_pi_cam"

# Encode image as base64
with open(IMAGE_PATH, "rb") as f:
    image_data = f.read()
image_base64 = base64.b64encode(image_data).decode('utf-8')

# Send request
url = f"{API_URL}/api/project/{PROJECT_ID}/image"
payload = {
    "timestamp": int(datetime.now(timezone.utc).timestamp() * 1000),
    "label_key": LABEL_KEY,
    "image_name": os.path.basename(IMAGE_PATH),
    "image_base64": image_base64
}

try:
    response = requests.post(url, json=payload, params={"token": TOKEN})
    response.raise_for_status()
    print("✅ Send successful")
    print(response.json())
except requests.exceptions.HTTPError as e:
    print(f"❌ Error: HTTP {e.response.status_code}")
    print(e.response.text)
except Exception as e:
    print(f"❌ Error: {e}")

Checking on Miniviz

When you run Preview…

3. Sending camera images periodically

Once the sample code works, you can start sending camera images at regular intervals.

Code

The full code is provided at the end of this document.

Viewing images in the Database

You can check the uploaded data from the Database menu.
All sent images are stored in the database.

If nothing appears here, the data transmission failed.
Please check the logs on your device.

Displaying images in Visualize

You can create graphs from the Visualize menu.
You can customize the graph type and how the data is displayed.

Sample Code (Periodic Sending)

#!/usr/bin/env python3
"""
Raspberry Pi USB Camera to Miniviz
"""
import requests
import base64
import os
import subprocess
import time
from datetime import datetime, timezone

# Miniviz configuration
PROJECT_ID = "PROJECT_ID"
TOKEN = "TOKEN"
API_URL = "https://api.miniviz.net"
LABEL_KEY = "raspberry_pi_cam"

# USB Camera configuration
DEVICE = "/dev/video0"
RESOLUTION = "640x480"
IMAGE_PATH = "image.jpg"

# Send interval (seconds)
SEND_INTERVAL = 60  # 1 minute

def capture_image():
    """Capture image with USB camera"""
    cmd = [
        "fswebcam",
        "-d", DEVICE,
        "-r", RESOLUTION,
        "--no-banner",
        "-S", "5",
        IMAGE_PATH
    ]
    print("[Info] Capturing image...")
    result = subprocess.run(cmd, capture_output=True, text=True)

    if result.returncode != 0:
        print(f"[Error] Capture failed: {result.stderr}")
        return False

    print("[Info] Image captured successfully")
    return True

def encode_image_to_base64(image_path):
    """Encode image file to base64"""
    with open(image_path, "rb") as f:
        image_data = f.read()
    return base64.b64encode(image_data).decode('utf-8')

def send_image_to_miniviz(image_path):
    """Send image to Miniviz API"""
    url = f"{API_URL}/api/project/{PROJECT_ID}/image"

    # Encode image to base64
    image_base64 = encode_image_to_base64(image_path)

    # Request payload
    payload = {
        "timestamp": int(datetime.now(timezone.utc).timestamp() * 1000),
        "label_key": LABEL_KEY,
        "image_name": os.path.basename(image_path),
        "image_base64": image_base64
    }

    try:
        response = requests.post(url, json=payload, params={"token": TOKEN})
        response.raise_for_status()
        print("[Info] Send successful")
        print(response.json())
        return True
    except requests.exceptions.HTTPError as e:
        print(f"[Error] HTTP {e.response.status_code}")
        print(e.response.text)
        return False
    except Exception as e:
        print(f"[Error] {e}")
        return False

def cleanup_image(image_path):
    """Delete sent image file (to save disk space)"""
    try:
        if os.path.exists(image_path):
            os.remove(image_path)
            print(f"[Info] Cleaned up: {image_path}")
    except Exception as e:
        print(f"[Warning] Failed to delete {image_path}: {e}")

def main():
    """Main process"""
    # Capture image with USB camera
    if not capture_image():
        print("[Error] Failed to capture image")
        return

    # Send to Miniviz
    success = send_image_to_miniviz(IMAGE_PATH)

    # Delete image file only on success (to save disk space)
    if success:
        cleanup_image(IMAGE_PATH)

if __name__ == "__main__":
    print("Starting miniviz image send test (press Ctrl+C to stop)")
    try:
        while True:
            main()
            time.sleep(SEND_INTERVAL)
    except KeyboardInterrupt:
        print("\n[Info] Stopped by user")

Lastly

You can also keep the video locally and send only snapshots, which can still be quite practical.
As a more advanced use case, combining images with AI to trigger notifications could be an interesting approach.

How to Send ESP32 Sensor Data to Miniviz for Real-time Visualization(Miniviz #1)

Yoshida.T — Sun, 30 Nov 2025 08:34:20 +0000

What is Miniviz?

Miniviz is a BI platform developed for individuals to accelerate IoT PoC (Proof of Concept). It enables you to easily achieve data transmission, storage, visualization, and notifications all in one place.

The main features are:

Database functionality
Graph/chart functionality
External alert functionality

https://miniviz.net/

What We'll Build

In this tutorial, we'll create a sample project that sends data from a temperature and humidity sensor and creates graphs to visualize the data.

What You'll Need

ESP32
USB cable (for data transfer)
Temperature and humidity sensor (DHT11 or similar)
Jumper wires
Breadboard (optional)

Steps

Set up ESP32 development environment (PlatformIO)
Connect sensor and implement source code (read temperature/humidity and send data)
Verify data transmission, create graphs, and set up notifications

1. ESP32 Development Environment Setup (PlatformIO)

We'll set up the ESP32 development environment using PlatformIO as a VS Code extension.

Download and install PlatformIO IDE
It's recommended to install it as a Visual Studio Code extension
Launch Visual Studio Code and verify that the PlatformIO extension is enabled
Create a new project

Select "New Project" from the PlatformIO home screen
Enter a project name (e.g., esp32-miniviz)
Select "ESP32 Dev Module" as the board
Select "Arduino" as the framework

Example platformio.ini File

[env:esp32doit-devkit-v1]
platform = espressif32
board = esp32doit-devkit-v1
framework = arduino
lib_deps = adafruit/DHT sensor library@^1.4.6
monitor_speed = 115200

Adding the DHT Library

The DHT sensor library for temperature and humidity sensors is imported in the configuration above.

2. Sensor Connection and Source Code Implementation

Sensor Connection

Connect a temperature and humidity sensor like DHT11 to the ESP32.

DHT11 Connection Example:

DHT11              ESP32
------             ----------------
(1) VCC  --------> 3.3V
(2) DATA --------> GPIO4
(3) NC   --------> -
(4) GND  --------> GND

Wiring Example

Here's a visual reference (apologies for the image quality):

Running the Data Transmission Sample

We'll create ESP32 code to send data to the Miniviz API.

The source code is provided at the end of this article.

Getting Project ID and Token

Create a Miniviz account -> Create a project -> Get your project ID and token

For more details, check the Quick Start Guide

Source Code Implementation and Build

Write the following content in the src/main.cpp file (replace PROJECT_ID and TOKEN with your actual values).

Build and upload the code. Verify in the serial monitor that the POST request is successful.

The sample code is provided at the end of this article.

3. Verify Data Transmission and Create Graphs

Verify Data Transmission

Open the Database in the sidebar, and you should see the parsed data displayed.

Create Graphs

Create a graph from the Visualize menu
Select a graph type (line chart is recommended)
Select temperature and humidity as data sources
Verify that the graph displays correctly

Get Notifications via Slack and Email!

Miniviz also has an external alert feature, so you can set up notifications as needed!

Source Code

The transmission interval is set to 90 seconds.

#include <Arduino.h>
#include <DHT.h>
#include <WiFi.h>
#include <HTTPClient.h>

//----------------------------------------
// Configuration
//----------------------------------------
const int PIN_DHT = 4;
DHT dht(PIN_DHT, DHT11);

const char *ssid = "WIFI_SSID";
const char *password = "WIFI_PASSWORD";

// Miniviz API
const char *project_id = "MINIVIZ_PROJECT_ID";
const char *token = "MINIVIZ_API_TOKEN";

String endpoint = String("https://api.miniviz.net/api/project/") +
                  project_id + "?token=" + token;

// Deep Sleep (90 seconds)
const uint64_t SLEEP_INTERVAL_US = 90ULL * 1000000ULL;


//----------------------------------------
// Wi-Fi Connection
//----------------------------------------
void connectWiFi()
{
  Serial.println("Connecting to Wi-Fi...");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  int retry = 0;
  while (WiFi.status() != WL_CONNECTED && retry < 30) {
    delay(300);
    Serial.print(".");
    retry++;
  }
  Serial.println();

  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("Wi-Fi connected");
  } else {
    Serial.println("Wi-Fi connection failed");
  }
}

//----------------------------------------
// NTP Time Synchronization
//----------------------------------------
void syncTime()
{
  Serial.println("Syncing NTP...");
  configTime(0, 0, "ntp.nict.jp", "time.google.com");

  struct tm timeinfo;
  while (!getLocalTime(&timeinfo)) {
    delay(200);
    Serial.print("*");
  }
  Serial.println("\nTime synced");
}

//----------------------------------------
// UNIX Timestamp in Milliseconds
//----------------------------------------
uint64_t getTimestampMs()
{
  struct timeval tv;
  gettimeofday(&tv, NULL);
  return (uint64_t)tv.tv_sec * 1000ULL + (tv.tv_usec / 1000ULL);
}

//----------------------------------------
// POST to Miniviz
//----------------------------------------
void sendToMiniviz(float temp, float humid)
{
  if (WiFi.status() != WL_CONNECTED)
    connectWiFi();

  HTTPClient http;
  http.begin(endpoint);
  http.addHeader("Content-Type", "application/json");

  uint64_t ts = getTimestampMs();

  String body = "{";
  body += "\"timestamp\":" + String(ts) + ",";
  body += "\"label_key\":\"esp32_home\",";
  body += "\"payload\":{";
  body += "\"temperature\":" + String(temp) + ",";
  body += "\"humidity\":" + String(humid);
  body += "}}";

  int code = http.POST(body);
  Serial.println("HTTP code: " + String(code));
  Serial.println(http.getString());
  http.end();
}

//----------------------------------------
// Setup
//----------------------------------------
void setup()
{
  Serial.begin(115200);
  delay(200);

  dht.begin();
  connectWiFi();
  syncTime();
}

//----------------------------------------
// Loop (exits after one iteration due to DeepSleep)
//----------------------------------------
void loop()
{
  float t = dht.readTemperature();
  float h = dht.readHumidity();

  Serial.printf("Temperature: %.2f°C  Humidity: %.2f%%\n", t, h);

  sendToMiniviz(t, h);

  Serial.println("Entering deep sleep...");
  esp_deep_sleep(SLEEP_INTERVAL_US);
}

Building Miniviz: A Minimalist BI Platform for IoT PoCs

Yoshida.T — Fri, 28 Nov 2025 02:28:49 +0000

What I Built

I built Miniviz, a minimalist BI platform to speed up IoT proof-of-concepts (PoCs).

https://miniviz.net/

The goal is intentionally simple:

Send time-stamped data
Store it without heavy setup
Visualize it quickly
Notify when something crosses a threshold

In many PoCs, the pain isn’t the sensor code—it’s everything around it (DB, auth, dashboards, alerts). Miniviz is my attempt to make that “cloud-side glue” thin enough that you can get to a first success fast.

A 10-minute Demo (curl only)

In this demo, we'll send a JSON event via curl, check it in the Database view, create a chart, and add an alert — all from a shell terminal, with no Python required.

1) Send a sample event

Generate a UNIX timestamp in milliseconds (pure shell):

TS=$(($(date +%s%N)/1000000))

Export your credentials:

export PROJECT_ID="YOUR_PROJECT_ID"
export TOKEN="YOUR_TOKEN"

Send a JSON payload:

curl -sS -X POST \
  "https://api.miniviz.net/api/project/${PROJECT_ID}?token=${TOKEN}" \
  -H "Content-Type: application/json" \
  -d "{
    \"timestamp\": ${TS},
    \"label_key\": \"local_pc\",
    \"payload\": {
      \"temperature\": 25.0,
      \"humidity\": 55.0,
      \"switch\": \"true\",
      \"system_status\": \"running\"
    }
  }"

2) Confirm it in the Database view

it in the Database view

Open the Database page. You should see parsed values like temperature, humidity, switch, etc.

3) Create a chart

Create a line chart using temperature (and optionally humidity) as the data source.

4) Add an alert (Slack / Email / Webhook)

Create a threshold alert like temperature > 30, then test it by sending another event with a higher temperature.

The Problem with Current IoT PoCs

IoT PoCs often get stuck on cloud-side setup before even getting to sensor or device implementation:

Database setup, permission management, visualization tooling, and notification integrations
AWS/GCP are powerful but often overkill for early PoCs
“Automation tools” can work, but time-series data with timestamps can get awkward once you care about consistency and repeatability

The result is that the time to “first working dashboard” becomes long, and PoCs lose momentum.

Philosophy & Design

Miniviz’s philosophy is pragmatic and deliberately limited:

Make storage + visualization + notifications available in one place
Minimize setup friction (a simple POST API)
Require no special SDK (works with ESP32, Python, curl, etc.)
Keep notification destinations minimal (start with what’s necessary)
Assume advanced analysis happens via CSV export in familiar tools
Support image storage as a separate category (object storage) with cost control (Pro plan)

For PoCs, “minimum viable and immediately usable” is often more valuable than “can do everything.”

Tech Stack

I chose a modern stack that’s sustainable for solo development:

Backend: FastAPI
Frontend: React (Next.js)
Database: PostgreSQL (Supabase)
Image storage: Google Cloud Storage (GCS)
Hosting: Cloud Run (GCP) for API, Vercel for frontend

Key Learnings (from solo development)

This is a solo project, so I had to choose an architecture that’s sustainable rather than “the perfect architecture.” Here are three trade-offs that mattered the most.

1) Going “modern” with hosting boosted development speed

Problem:
IoT PoCs often stall on deployment and ops before features. In solo development, server management and environment differences become immediate technical debt.

Decision:
I moved the API to Cloud Run and the frontend to Vercel, making deployment nearly one-click and reducing environment friction.

Trade-off:
Vendor lock-in increases. But for PoCs, the most important thing is the distance to the first successful experience, so I accepted it.

Learning:
For solo IoT projects, a sustainable deployment workflow matters more than architectural purity.

2) For images, object storage was the right choice over a database

Problem:
IoT isn’t just numeric telemetry. Field photos, meter snapshots, and other images often matter—even in PoCs.

Decision:
I store images in GCS and keep only metadata (URL/key/timestamp/label) in PostgreSQL.

Trade-off:
Uploads require constraints (signed URLs, size limits), permission design, and cost awareness. I chose to control this via plan tiers.

Learning:
Images aren’t a “small feature.” They are a separate category that includes storage, permissions, and cost design.

3) Authentication is always a UX vs security trade-off (especially for IoT)

Problem:
Complex auth like OAuth is not practical for many devices. But careless token handling leads to leaks and abuse.

Decision:
I used a low-friction project_id + token approach so that any device/language can send data quickly.

Trade-off:
Token risk remains, so you need a baseline: scoped permissions, revocation/rotation, and rate limiting.

Learning:
“You can secure it later” doesn’t work—even for PoCs. Lightweight auth needs a non-careless baseline from day one.

Try it (optional)

Miniviz is live at https://miniviz.net
and the quickstart is at https://docs.miniviz.net/quickstart.html.

What’s Next

I’ll keep maintaining Miniviz while improving:

More user-facing recipes and references
UI/UX
International docs and onboarding

If you try it and run into friction, I’d love to hear what blocked you—those are usually the most valuable signals for a PoC-focused tool.

DEV Community: Yoshida.T

Visualize Temperature & Humidity with Raspberry Pi Pico W DHT11 — Build an IoT Prototype with Miniviz

Visualize Temperature & Humidity with Raspberry Pi Pico W × DHT11 — Build an IoT Prototype with Miniviz

Table of contents

What is Miniviz?

What you’ll build

What you need

Wiring the Pico and DHT11

Pinout

Reading sensor data

Set up VS Code and MicroPython

Install the Pico firmware

Sample read script

Sending data to Miniviz

Get your project ID and token

Source code to send to Miniviz

Viewing data in Miniviz

Creating a chart

Wrap-up

Pro plan beta / monitor program

Tags

Build a Simple Raspberry Pi Snapshot Monitor with a USB Camera

What is Miniviz?

What we will do

What you need

Connecting the Raspberry Pi and USB Camera

Checking the image captured by the camera

Sending camera images to Miniviz

1. Obtain your Project ID and Token

2. Call the Image API to send a sample image

Sending a sample image (Python)

Checking on Miniviz

3. Sending camera images periodically

Code

Viewing images in the Database

Displaying images in Visualize

Sample Code (Periodic Sending)

Lastly

How to Send ESP32 Sensor Data to Miniviz for Real-time Visualization(Miniviz #1)

What is Miniviz?

What We'll Build

What You'll Need

Steps

1. ESP32 Development Environment Setup (PlatformIO)

Example platformio.ini File

Adding the DHT Library

2. Sensor Connection and Source Code Implementation

Sensor Connection

Wiring Example

Running the Data Transmission Sample

Getting Project ID and Token

Source Code Implementation and Build

3. Verify Data Transmission and Create Graphs

Verify Data Transmission

Create Graphs

Get Notifications via Slack and Email!

Source Code

Building Miniviz: A Minimalist BI Platform for IoT PoCs

What I Built

A 10-minute Demo (curl only)

1) Send a sample event

2) Confirm it in the Database view

3) Create a chart

4) Add an alert (Slack / Email / Webhook)

The Problem with Current IoT PoCs

Philosophy & Design

Tech Stack

Key Learnings (from solo development)

1) Going “modern” with hosting boosted development speed

2) For images, object storage was the right choice over a database

3) Authentication is always a UX vs security trade-off (especially for IoT)

Try it (optional)

What’s Next