Forem: Ikegbo Ogochukwu

How to Change Wi-Fi Details on a Headless Raspberry Pi When You Don’t Know the Current Network

Ikegbo Ogochukwu — Fri, 08 May 2026 12:05:34 +0000

If you’ve ever worked with a headless Raspberry Pi, you’ve probably faced this problem:

The Raspberry Pi was previously connected to a Wi-Fi network
You do not know which network it is connected to
You cannot connect a monitor, keyboard, or mouse
SSH is your only option
The Pi is no longer appearing on your current network

This usually happens when:

You move to a new location
Your Wi-Fi name/password changes
Someone else configured the Pi
You forgot the old network credentials

In this guide, I’ll show you how to:

Diagnose the problem
Reconfigure Wi-Fi without a monitor
Force the Pi onto a new network
Recover SSH access

The methods below work for:

Raspberry Pi 3
Raspberry Pi 4
Raspberry Pi 5
Raspberry Pi Zero W/2W

Understanding the Problem

A Raspberry Pi configured for headless access boots and automatically tries to connect to the Wi-Fi credentials saved inside:

wpa_supplicant.conf

If:

the saved Wi-Fi no longer exists
the password changed
or the Pi is too far from the router

then the Pi never joins the network.

Since SSH depends on network access, you lose remote control completely.

Method 1 — Edit Wi-Fi Credentials Directly from the SD Card (Best Method)

This is the fastest recovery method.

Step 1 — Remove the SD Card

Power off the Raspberry Pi safely.

Remove the microSD card and insert it into your computer using:

SD card reader
USB adapter
laptop SD slot

Step 2 — Open the Boot Partition

After inserting the SD card, you’ll see a small partition called:

boot
bootfs

Open it.

This partition is readable on:

Windows
Linux
macOS

Step 3 — Create or Edit `wpa_supplicant.conf`

Inside the boot partition, create a file named:

wpa_supplicant.conf

If it already exists, edit it.

Paste this:

country=NG
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
    ssid="YOUR_WIFI_NAME"
    psk="YOUR_WIFI_PASSWORD"
}

Example:

country=NG
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
    ssid="MTN_Home"
    psk="mysecurepassword"
}

Why `country=NG` Matters

A lot of people ignore this.

The country code controls:

Wi-Fi regulatory channels
allowed radio frequencies
transmission compliance

If your country code is wrong:

Wi-Fi may fail silently
some channels become inaccessible

For Nigeria, use:

country=NG

Not:

US

unless you are actually in the US.

Do You Need to Remove Old Wi-Fi Networks?

Usually, no.

The Raspberry Pi can store multiple Wi-Fi networks and automatically connect to whichever known network is available.

For example:

network={
    ssid="Old_Wifi"
    psk="oldpassword"
}

network={
    ssid="New_Wifi"
    psk="newpassword"
}

If Old_Wifi is unavailable, the Pi will try New_Wifi.

When Should You Remove Old Networks?

You may want to remove old saved networks if:

The Pi keeps reconnecting to the wrong network
Multiple nearby networks are available
The old Wi-Fi has poor internet access
You want cleaner configuration management
You are deploying the Pi to a new environment permanently

In that case, simply delete the old network={} block from:

wpa_supplicant.conf

and leave only the new network.

Best Practice

For classroom projects, IoT deployments, and Raspberry Pi labs, it is usually better to:

remove outdated Wi-Fi networks
keep only the active network
avoid connection conflicts

This makes troubleshooting much easier later.

Step 4 — Enable SSH

Still inside the boot partition:

Create an empty file named:

ssh

No extension.

Not:

ssh.txt
ssh.conf

Just:

ssh

This enables the SSH server during boot.

Step 5 — Reinsert SD Card and Boot

Insert the SD card back into the Raspberry Pi.

Power it on.

Wait about:

1–3 minutes

for the Pi to boot and connect.

Step 6 — Find the Raspberry Pi on the Network

Now you need the Pi’s IP address.

Option A — Use Fing (Recommended)

Install:

Fing (Android/iPhone)
Fing Desktop

Scan your network.

Look for:

raspberrypi
Raspberry Pi Foundation
hostname you configured

Option B — Use Router Admin Page

Check:

Connected Devices
DHCP Clients
LAN Devices

You may see:

raspberrypi.local

or an IP like:

192.168.1.12

Option C — Use `ping`

Try:

ping raspberrypi.local

or:

ping yourhostname.local

Step 7 — SSH Into the Pi

Once you have the IP:

ssh pi@192.168.1.12

Or:

ssh username@hostname.local

Example:

ssh stanley@raspberrypi.local

What If You Don’t Know the Username?

Modern Raspberry Pi OS no longer uses:

pi
raspberry

by default.

The username is whatever was set during OS imaging.

If you forgot it:

reflash the OS
or inspect old documentation

Method 2 — Reflash Using Raspberry Pi Imager (Cleanest Option)

If recovery fails completely, just rewrite the OS.

Install Raspberry Pi Imager

Download from:

Raspberry Pi Imager

Configure Headless Setup Properly

Inside Raspberry Pi Imager:

Click:

NEXT → EDIT SETTINGS

Configure:

General

Hostname
Username
Password
Wi-Fi SSID
Wi-Fi Password
Country

Services

Enable:

Choose:

Password authentication

Then write the OS.

This is the most reliable method.

Troubleshooting Tips

1. Pi Not Appearing on Network

Possible causes:

Wrong Wi-Fi password
Wrong country code
Weak Wi-Fi signal
5GHz unsupported network
Hidden SSID

Try:

mobile hotspot
2.4GHz Wi-Fi
moving Pi closer

2. SSH “Hostname Could Not Be Resolved”

This means:

the Pi is not on the network
or mDNS isn’t working

Use direct IP instead.

3. SSH Connection Refused

Usually:

SSH disabled
Pi still booting
firewall issue

Recreate the empty ssh file.

4. Raspberry Pi Only Supports 2.4GHz

Some older Pis cannot use:

5GHz
Wi-Fi 6 only networks

Enable:

mixed mode
2.4GHz compatibility

Bonus Tip — Use Your Phone Hotspot

If you don’t know the old network:

Create a hotspot using:

same Wi-Fi name
same password

as the old network.

The Pi may reconnect automatically.

This is one of the fastest recovery tricks.

Recommended Headless Workflow

Here’s the workflow I now use for every Raspberry Pi deployment:

During OS Imaging

Always configure:

hostname
SSH
Wi-Fi
username/password

inside Raspberry Pi Imager.

Keep Backup Notes

Save:

hostname
username
password
Wi-Fi used

inside:

Notion
Google Docs
password manager

Use Static Hostnames

Instead of:

raspberrypi

Use:

cv-group1
iot-node2
weather-station

This makes network discovery easier.

Final Thoughts

Headless Raspberry Pi setups are incredibly powerful, but Wi-Fi issues can lock you out completely if you don’t plan ahead.

The good news is:
you usually do NOT need a monitor.

As long as you can access the SD card, you can:

change Wi-Fi
enable SSH
recover the device
regain remote access

Once you master this workflow, managing remote Raspberry Pis becomes much easier — especially in classrooms, IoT deployments, robotics projects, and AI edge systems.

Happy building 🚀

API Keys vs. Access Tokens: What's the Real Difference?

Ikegbo Ogochukwu — Wed, 06 May 2026 13:39:41 +0000

As a developer, you’ve definitely seen them: x-api-key, Authorization: Bearer <token>, and Personal Access Tokens.

If you've ever wondered if they are just different names for the same thing—they aren't. Using the wrong one can leave your app wide open to security risks.

Here is the "explain like I'm five" breakdown.

🔑 The API Key: The "Project ID Card"

Think of an API Key as a static ID card for an entire project or application.

Who is it? It identifies the application (e.g., "This request is coming from the WeatherDashboard app").
Life Span: Long-lived. It usually doesn't expire unless you manually rotate it.
Best for: Accessing public data (maps, weather) or simple server-to-server tasks where no specific user login is required.

Example Usage:

// Simple but less secure - anyone with the key can use it.
const url = `https://weather.com{YOUR_API_KEY}`;

🎟️ The Access Token: The "Visitor Badge"

An Access Token (like a JWT) is more like a temporary visitor badge.

Who is it? It identifies the specific user and what they are allowed to do.
Life Span: Short-lived. It expires quickly (often in 1 hour) and needs a "refresh" to stay active.
Best for: Private user data (Gmail, Spotify, Banking). It ensures that even if a token is stolen, the damage is limited by time and scope.

📊 Side-by-Side Comparison

Feature	API Key	Access Token
Identifies	The Application	The User
Expiration	Usually Permanent	Short-lived (Expires)
Security	Low (Static)	High (Dynamic)
Common Flow	Generated in a Portal	Generated via Login (OAuth)

💡 When to use which?

Use an API Key when:

You are calling a public service (like Google Maps).
You need to track usage for billing (e.g., "App X used 1,000 requests").
You are doing internal server-to-server communication in a trusted environment.

Use an Access Token when:

You are dealing with user-specific data (e.g., reading my emails).
Security is a priority (you want the credential to expire).
You need "granular permissions" (e.g., "This app can read my profile but NOT post for me").

🛡️ Pro-tip: Never Hardcode!

Whether you use a key or a token, never commit them to GitHub. Always use environment variables and a .env file.

What are you currently using in your latest project? Drop a comment below! 👇

🚀 Setting Up Raspberry Pi & Camera for AI Projects (Complete Command Guide)

Ikegbo Ogochukwu — Mon, 04 May 2026 18:34:12 +0000

If you're working with a Raspberry Pi for computer vision or AI projects, getting everything set up can be confusing—especially with newer devices like the Raspberry Pi 5.

This guide compiles all essential commands used for:

Setting up your Raspberry Pi
Configuring network access
Enabling remote control
Troubleshooting camera issues
Capturing images

🧠 1. System Setup & Updates

Before doing anything, your system should be updated:

sudo apt update
sudo apt upgrade

🌐 2. Network & IP Configuration

Check IP address

hostname -I

👉 This is needed for:

SSH connection
VNC connection

🔐 3. Remote Access Setup

Enable SSH and VNC

sudo raspi-config

Then navigate:

Interface Options → Enable SSH
Interface Options → Enable VNC

Connect via SSH

ssh pi@<IP_ADDRESS>

Example:

ssh pi@192.168.43.25

🖥️ 4. VNC (Remote Desktop Access)

Used when you want full GUI access from your laptop.

Steps:

Enable VNC (see above)
Install VNC Viewer on your laptop
Connect using:

<IP_ADDRESS>

📸 5. Camera System (Important Update)

On modern Raspberry Pi OS:

Camera is enabled by default (libcamera system)

👉 You will NOT see "Camera" in raspi-config anymore.

🧪 6. Test Camera

Preview camera

rpicam-hello

👉 Works only on GUI (monitor or VNC)

Capture image

rpicam-still -o test.jpg

Record video

rpicam-vid -t 5000 -o video.h264

📂 7. File Management Commands

List files

ls

Create folder

mkdir dataset
cd dataset

🔁 8. Capture Multiple Images

for i in {1..10}; do rpicam-still -o img_$i.jpg; sleep 2; done

🖼️ 9. Open Image (on Raspberry Pi GUI)

xdg-open test.jpg

🧪 10. Python + OpenCV Setup

Start Python

python3

Import OpenCV

import cv2

Load image

img = cv2.imread("test.jpg")

Resize image

resized = cv2.resize(img, (224, 224))
cv2.imwrite("resized.jpg", resized)

Convert to grayscale

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imwrite("gray.jpg", gray)

Convert to HSV

hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
cv2.imwrite("hsv.jpg", hsv)

Exit Python

exit()

⚠️ 11. Common Troubleshooting

Camera not working?

Check:

Cable orientation
Proper connection
Correct port (Pi 5 has 2 ports)

No preview?

SSH = No preview
VNC/Monitor = Preview works

Restart system

sudo reboot

🧠 Key Takeaways

✔ Raspberry Pi OS now uses libcamera
✔ No manual camera enable needed
✔ rpicam-* commands replace raspistill
✔ SSH is for control, not display
✔ VNC gives full desktop access

🎯 Final Thoughts

Once your Raspberry Pi and camera are set up:

👉 You are ready to:

Collect image datasets
Train AI models
Deploy computer vision applications

🔥 If you found this useful

Drop a ❤️
Share with someone learning Raspberry Pi
Follow for more AI + Embedded Systems content

COMPLETE COURSE: Git & GitHub (From Zero to Advanced)

Ikegbo Ogochukwu — Thu, 30 Apr 2026 17:59:55 +0000

📘 COURSE OVERVIEW

This course gives you a rock-solid foundation in:

Git (local version control)
GitHub (remote collaboration)
Real-world workflows (branching, merging, collaboration)

Git = tracks changes locally
GitHub = cloud platform for collaboration

🧩 MODULE 1: WHAT IS GIT?

🔹 Definition

Git is a Version Control System (VCS) that:

Tracks every change in your files
Stores history (who, when, what changed)
Allows rollback to previous versions

🔹 Key Features

Tracks any file type (code, text, images, videos)
Maintains multiple versions
Enables safe experimentation

🔹 Real-world Problem Git Solves

You:

Build a project → client likes it
Update it → client wants old version

👉 Without Git → you're stuck
👉 With Git → you restore instantly

🔗 MODULE 2: GIT vs GITHUB

🔹 Git

Local tool
Runs on your computer

🔹 GitHub

Cloud platform
Stores repositories online
Enables collaboration

🔹 Analogy

Git = coffee ☕
GitHub = coffee shop 🏪

🔹 Alternatives

GitLab
Bitbucket

🏗️ MODULE 3: GIT ARCHITECTURE

🔹 Two Parts

Local
Remote (GitHub)

🔹 Workflow Stages

Working Directory

Where you edit files

Staging Area

Temporary holding area

Repository

Permanent storage (commit history)

🔁 Workflow Summary

Working Directory → Staging Area → Local Repo → Remote Repo

⚙️ MODULE 4: INSTALLING GIT

🔹 Steps

Go to official Git website
Download for:

Windows (32/64-bit)
Mac (Homebrew)
Linux

🔹 Verify Installation

git --version

✔ If installed → shows version
❌ Else → error

💻 MODULE 5: TERMINAL BASICS

🔹 Important Commands (NOT Git commands)

cd       # change directory
pwd      # show current path
mkdir    # create folder
touch    # create file
ls       # list files

📁 MODULE 6: CREATING A PROJECT

🔹 Steps

cd Desktop
mkdir git-1
cd git-1

touch 1.txt
touch 2.txt

mkdir my-folder
cd my-folder
touch 3.txt

🚀 MODULE 7: INITIALIZING GIT

🔹 Command

git init

🔹 What Happens

Creates hidden .git folder
Git starts tracking project

ls -la

👉 Shows .git folder

🌐 MODULE 8: GITHUB REPOSITORY

🔹 Steps

Go to GitHub
Create new repo
Add files online
Commit changes

📥 MODULE 9: CLONING A REPO

🔹 Command

git clone <repo-url>

🔹 Result

Downloads remote repo
Creates local copy

🔍 MODULE 10: TRACKING CHANGES

🔹 Command

git status

🔹 Shows:

Modified files
New files
Deleted files

📦 MODULE 11: STAGING (git add)

🔹 Purpose

Move changes → staging area

🔹 Variations

1. Add everything

git add --all
git add -A

2. Add current directory

git add .

3. Add specific file

git add file.txt

4. Add by extension

git add *.txt

5. Add using wildcard

git add *

⚠️ Does NOT include deleted files

🔄 MODULE 12: UNSTAGING

🔹 Command

git reset

👉 Moves files back to working directory

💾 MODULE 13: COMMITTING

🔹 Command

git commit -m "message"

🔹 Meaning

Permanently saves changes

⚠️ First-time Setup

git config --global user.email "you@email.com"
git config --global user.name "Your Name"

⏪ MODULE 14: UNDO COMMITS

git reset HEAD~

👉 Undo last commit

❌ MODULE 15: DELETING FILES

🔹 Delete + stage

git rm file.txt

🔹 Force delete

git rm -f file.txt

🔹 Remove from Git only

git rm --cached file.txt

📜 MODULE 16: VIEW HISTORY

git log

Short version:

git log --oneline

🌿 MODULE 17: BRANCHING

🔹 Create branch

git branch development

🔹 View branches

git branch

🔹 Switch branch

git checkout development

🔹 Concept

Main = stable code
Branch = experimentation

🔀 MODULE 18: MERGING

🔹 Merge branch

git merge development

⚠️ MODULE 19: MERGE CONFLICTS

Occurs when:

Same file edited in different branches

🔹 Resolution Steps

Open file
Choose correct version
Remove conflict markers
Commit

⏳ MODULE 20: TIME TRAVEL

🔹 Go to old commit

git checkout <commit-id>

🔹 Return to latest

git checkout main

🔍 MODULE 21: COMPARE CHANGES

git diff <commit1> <commit2>

Red → removed
Green → added

☁️ MODULE 22: REMOTE OPERATIONS

🔹 Push

git push origin main

🔹 Fetch

git fetch

🔹 Pull

git pull

🔁 Summary

push → local → remote
fetch → remote → local (no merge)
pull → fetch + merge

🔄 MODULE 23: RESTORE

🔹 Undo changes

git restore file.txt

🔹 Restore all

git restore .

🔹 Unstage

git restore --staged file.txt

📦 MODULE 24: STASH

🔹 Save unfinished work

git stash

🔹 Retrieve later

git stash apply

🧠 FINAL SUMMARY

You now understand:

Git fundamentals
Local vs remote workflow
Full command lifecycle
Branching & collaboration
Conflict resolution
Undoing mistakes safely

Git and GitHub tutorials for Beginners

Ikegbo Ogochukwu — Thu, 30 Apr 2026 11:03:44 +0000

🔰 1. What is Git?

Git = Version Control System

👉 It helps you:

Track changes in your code
Go back to previous versions
Collaborate with others safely

Think of it like:

“Google Docs version history… but for code”

Git records every change as a snapshot (commit) ([FreeCodeCamp][1])

🌐 2. What is GitHub?

GitHub is a cloud platform that hosts Git repositories
It allows:
- Collaboration
- Sharing code
- Team development

👉 Key idea:

Git = tool
GitHub = online platform using Git ([product.hubspot.com][2])

🏗️ 3. Core Git Concepts (VERY IMPORTANT)

📁 Repository (Repo)

A project folder tracked by Git

🧾 Commit

A saved snapshot of your work

📦 Staging Area

Where you prepare changes before saving

🌿 Branch

A separate version of your project (for new features)

🔀 Merge

Combining branches together

⚙️ 4. Basic Git Workflow (The Heart of Everything)

This is the main flow taught in the video:

Step 1: Initialize Git

git init

👉 Turns your folder into a Git repository

Step 2: Add Files

git add .

👉 Moves files to the staging area

Step 3: Commit Changes

git commit -m "Your message"

👉 Saves a snapshot of your work

Step 4: Connect to GitHub

git remote add origin <repo-url>

Step 5: Push to GitHub

git push -u origin main

👉 Uploads your code online

🔄 5. Everyday Git Commands

Check status

git status

See history

git log

Download updates

git pull

Upload changes

git push

🌿 6. Working with Branches (Key Skill)

Create a branch

git checkout -b feature-name

Switch branch

git checkout main

Merge branch

git merge feature-name

👉 Why branches matter:

Work on features without breaking main code ([product.hubspot.com][2])

🤝 7. Collaboration Workflow (GitHub Flow)

This is how teams work:

Create branch
Make changes
Push branch
Open Pull Request (PR)
Review
Merge

👉 Pull Request = “Please review my changes”

🧠 8. Mental Model (Very Important)

Think of Git like this:

Working Directory → Staging → Commit → GitHub

Working → you edit files
Staging → you prepare changes
Commit → you save version
GitHub → you share it

⚡ 9. Common Beginner Mistakes (From the Video)

❌ Forgetting to git add
❌ Bad commit messages
❌ Working directly on main branch
❌ Not pulling before pushing

🚀 10. Your First Practice Exercise

Try this:

mkdir my-project
cd my-project
git init

echo "Hello Git" > file.txt
git add .
git commit -m "First commit"

# connect to GitHub repo
git remote add origin <your-repo-url>
git push -u origin main

🔐 Android App Signing: Why the "Keystore" is Your Most Important File

Ikegbo Ogochukwu — Tue, 28 Apr 2026 22:35:07 +0000

If you are a new Android developer, there is one file that can literally make or break your entire career: the Keystore.
In this post, let’s break down what Android App Signing actually is, why it matters for security, and how Google Play App Signing saved us all from potential disaster.

🧱 The Basics: What is an App Signature?

Think of an app signature as a digital wax seal.
When you build an APK or AAB, you sign it with a private key. This signature tells the Android OS:

Identity: This app was created by Developer X.
Integrity: This app hasn't been modified or tampered with since it was signed.

🛡️ The "Secure Update" Model

The most important thing to understand is how Android handles updates.
When you try to install an update over an existing app, Android checks if the new signature matches the old signature.

Matches? The update proceeds and your user data is safe.
Doesn't match? Android throws an error and blocks the install.

This prevents a hacker from creating a "fake" update to your app to steal user passwords or data.

😱 The "Lost Key" Nightmare (The Old Way)

Before 2017, if you lost your .jks (Java Keystore) file or forgot the password, you were finished.
Because the signature is the only way Android identifies the developer, losing the key meant you could never update your app again. You would have to upload a completely new app with a new package name, losing all your installs and reviews.

🚀 How "Google Play App Signing" Fixed It

Google introduced Play App Signing to solve this exact problem. It splits the signing into two parts:

The Upload Key: This is the key you keep. You sign your app with it and upload it to Google.
The App Signing Key: Google keeps this master key in their secure "Vault."

The big win: If you lose your Upload Key, you just message Google Support. They verify your ID, reset the key, and you're back in business. The App Signing Key (the one the users see) never changes, so the update chain is never broken.

🛠️ Quick Pro-Tips for Devs:

Never commit your .jks file to GitHub (even in a private repo). Use Environment Variables or Secrets.
Always opt-in to Google Play App Signing for new apps.
Backup your keystore in a secure password manager like Bitwarden or 1Password.

Final Thoughts

App signing isn't just a technical hurdle; it’s the foundation of trust between you and your users. Treat your keys like your house keys—don't lose them, and don't give them to anyone else!
Have you ever had a "Lost Keystore" horror story? Let’s talk in the comments! 👇

Stop Losing Progress: Setting Up a Pro Jupyter Workflow in VS Code (No More Colab Timeouts!)

Ikegbo Ogochukwu — Tue, 21 Apr 2026 08:46:18 +0000

The Problem: The "Colab Heartbreak"

We’ve all been there: You’re 40 epochs into a multimodal model for crop disease detection, and suddenly—Session Terminated. Your variables are gone, your local drive isn't synced, and you have to start over.
While Google Colab is great for quick scripts, serious AI projects (like my current multimodal yield prediction system) need persistence and the power of a local IDE.

Why VS Code for Jupyter?

IntelliSense: Better code completion than any browser-based notebook.
Local Environment Control: No more !pip install every time you open the file.
Git Integration: Version control your experiments easily.
The Best of Both Worlds: Use your local UI while connecting to powerful cloud GPUs (like Paperspace or Saturn Cloud).

Step 1: The Essentials

First, grab the Jupyter Extension from the VS Code Marketplace. This transforms VS Code into a full-featured notebook editor.

Step 2: Virtual Environment (The Secret to Stability)

Don't install your ML libraries globally! Create a dedicated environment for your project:

Create the env

python -m venv crop_ai_env

Activate it

source crop_ai_env/bin/activate # Mac/Linux# .\crop_ai_env\Scripts\activate # Windows

Install the kernel connector

pip install ipykernel tensorflow-gpu pillow pandas

Step 3: Launching the Notebook

Create a file named experiment.ipynb.
Look at the top right corner of the editor. Click Select Kernel.
Choose your crop_ai_env.

Tip: If you don't see it, press Ctrl+Shift+P and run "Python: Select Interpreter" first.

Step 4: Pro-Tip for Long Training Runs

If you are doing heavy transfer learning (like MobileNetV3), use a Checkpoint Callback. This ensures that even if your computer restarts, your model weights are safe on your drive:

checkpoint_path = "checkpoints/crop_model_v1.ckpt"cp_callback = tf.keras.callbacks.ModelCheckpoint(
filepath=checkpoint_path,
save_weights_only=True,
verbose=1
)

Your model.fit() now has a safety net

model.fit(train_data, epochs=50, callbacks=[cp_callback])

Conclusion

Switching from Colab to VS Code + a local virtual environment (synced via GitHub or a Cloud Drive) has saved me hours of re-training time. If you're building lightweight TFLite models for offline use, this local-first workflow is a game-changer.

What’s your biggest frustration with browser-based notebooks? Let’s discuss in the comments!

Fixing a Flutter Release APK Build That Failed on Windows

Ikegbo Ogochukwu — Thu, 16 Apr 2026 13:27:12 +0000

How I diagnosed a misleading Gradle failure, separated a temporary Maven network issue from the real Android packaging problem, and fixed the release APK build with a small Gradle change

Introduction

I was building a Flutter release APK on Windows for tester distribution and ran into a confusing sequence of build failures.

The first error looked like a dependency-resolution problem:

Could not GET 'https://repo.maven.apache.org/...'
No such host is known (repo.maven.apache.org)

That made it look like the project or Firebase setup was broken.

After retrying once the network recovered, the real build blocker appeared:

Execution failed for task ':app:extractReleaseNativeSymbolTables'.
Failed to create MD5 hash for file ... libflutter.so.sym.temp-stream ...

This is the kind of issue that wastes time because the first failure distracts you from the second one. The Maven error was temporary. The actual release-build problem was native symbol extraction during Android packaging on Windows.

This post explains how I diagnosed it and the small fix that got the APK building successfully.

The goal

The goal was simple:

produce a signed release APK
share it directly with testers
avoid changing unrelated parts of the Android build

The project already had release signing configured, so this was not a keystore or package-name problem.

Step 1: Separate the temporary network error from the real build issue

The first failure was:

Could not resolve all files for configuration ':firebase_core:releaseRuntimeClasspath'
Could not download error_prone_annotations-2.26.0.jar
No such host is known (repo.maven.apache.org)

That is not a Flutter code issue.

It means Gradle could not reach Maven Central at that moment. Before changing any project files, I verified whether the host was reachable from the machine.

Useful checks on Windows:

nslookup repo.maven.apache.org
Test-NetConnection repo.maven.apache.org -Port 443

Once Maven Central was reachable again, the dependency download issue disappeared.

That was important, because fixing the wrong problem would have been wasted effort.

Step 2: Retry the build and read the next failure carefully

After the network issue cleared, the build failed again, but with a different error:

Execution failed for task ':app:extractReleaseNativeSymbolTables'.
Cannot access output property 'outputDir' of task ':app:extractReleaseNativeSymbolTables'.
Failed to create MD5 hash for file ... libflutter.so.sym.temp-stream ... as it does not exist.

This pointed to Android native symbol extraction, not Firebase, not signing, and not dependency resolution.

That distinction matters.

By this point, the release APK build was already far enough along to show that:

Flutter dependencies were resolving
Firebase packages were not the main blocker
the Android project structure was basically valid

The failure was happening in the release packaging phase.

Step 3: Identify what was actually safe to disable

For a tester APK, I did not need packaged native debug symbols.

That made the fix straightforward: disable native debug symbol packaging for the release build.

In android/app/build.gradle.kts, I updated the release build type to set:

ndk {
    debugSymbolLevel = "none"
}

The relevant release block became:

buildTypes {
    release {
        isMinifyEnabled = true
        isShrinkResources = true
        ndk {
            debugSymbolLevel = "none"
        }
        if (hasKeystoreConfig) {
            signingConfig = signingConfigs.getByName("release")
        } else {
            signingConfig = signingConfigs.getByName("debug")
        }
    }
}

This was a targeted fix. It did not relax signing. It did not remove shrinking. It only stopped the build from trying to package native debug symbols that were triggering the failure.

Step 4: Rebuild the APK

From the Flutter project root, I reran:

flutter pub get
flutter build apk --release

After the debugSymbolLevel = "none" change, the build completed successfully and produced:

build\app\outputs\flutter-apk\app-release.apk

In my case, the resulting APK was about 64.5 MB, which was fine for direct tester distribution.

Warnings that looked scary but were not the blocker

During the build, there were also warnings like these:

source value 8 is obsolete
target value 8 is obsolete

and:

Font asset "MaterialIcons-Regular.otf" was tree-shaken

Those warnings were not what caused the release build to fail.

It is worth calling that out because large build logs often mix harmless warnings with the real failure, and it is easy to chase the wrong thing.

Why this fix made sense

This was a pragmatic release-build decision.

For a tester APK, the priority was:

get a stable release artifact
keep minification and shrinking enabled
avoid unnecessary Gradle/NDK packaging work that was failing on this environment

If I were setting up a more advanced crash-symbol workflow later, I could revisit symbol generation in a more controlled release pipeline. But for immediate tester distribution, disabling native debug symbol packaging was the right tradeoff.

Final takeaway

The key lesson was not just the Gradle fix. It was the debugging sequence:

verify whether the first error is actually environmental
retry once the environment is healthy
fix the first reproducible project-level failure, not the first scary message in the log

In this case:

the Maven Central error was temporary network/DNS trouble
the actual reproducible blocker was extractReleaseNativeSymbolTables
the successful fix was setting debugSymbolLevel = "none" in the release build

If your Flutter release APK build fails on Windows during native symbol extraction, and you do not need packaged native symbols for that build, this is a clean fix worth trying.

Build command recap

flutter pub get
flutter build apk --release

Gradle fix recap

ndk {
    debugSymbolLevel = "none"
}

The Flutter Release Gauntlet: How to Build Your First Android APK Without the Headache

Ikegbo Ogochukwu — Thu, 16 Apr 2026 13:03:10 +0000

You’ve spent weeks perfecting your Flutter app. The widgets are beautiful, the state management is solid, and it runs perfectly on your emulator. But now comes the real challenge: getting it onto a real device.
In this guide, we’ll skip the fluff and look at exactly how to build and share your first Android APK.

1. The Quick & Dirty: Generating Your First APK

If you just want to send a file to your friend or client right now, the standard command is your best friend:

flutter build apk --release

What’s happening here?
Flutter is "tree-shaking" your code—removing unused resources—and compiling your Dart code into a high-performance release binary. Once finished, you’ll find your prize at:
build/app/outputs/flutter-apk/app-release.apk.

2. The "Fat APK" Problem (and the Solution)

The standard build command creates a "Fat APK," which contains code for all device architectures (arm64, armeabi, x86_64). While convenient, it makes your file size unnecessarily large.
To create smaller, optimized files for specific devices, use:

flutter build apk --split-per-abi

This gives you three separate APKs. Most modern phones will use the app-arm64-v8a-release.apk version.

3. Signing Your App (Don't Skip This!)

Android won’t let you install a "blank" app for long. To make your app official, you need a digital signature called a Keystore.

Generate the key: Use the keytool command in your terminal to create a .jks file.
Reference it: Create a key.properties file in your android/ folder to store your passwords.
Update Gradle: Configure your android/app/build.gradle to use these credentials during the build process.

Pro Tip: Never, ever upload your key.properties or .jks file to GitHub. Add them to your .gitignore immediately.

4. APK vs. App Bundle (AAB): Which one do you need?

Use APK for direct sharing (WhatsApp, Google Drive, or Slack).
Use AAB (flutter build appbundle) for the Google Play Store. Google now requires AABs because they allow the store to generate the smallest possible APK for every specific user.

5. Final Checklist Before You Share

Change the App Name: Update the android:label in your AndroidManifest.xml so it doesn't just say "Flutter App" on the home screen.
Update the Package Name: Change com.example.yourapp to something unique like com.yourname.appname.
Add an Icon: Use the flutter_launcher_icons package to replace the default Flutter logo with your own branding.

Summary Table: Your Build Toolkit

Goal	Command	Output
Quick Test	flutter build apk	Fat APK
Small File	flutter build apk --split-per-abi	Multiple ABI-specific APKs
Play Store	flutter build appbundle	.aab file
Clean Start	flutter clean	Clears old build files

Forem: Ikegbo Ogochukwu

How to Change Wi-Fi Details on a Headless Raspberry Pi When You Don’t Know the Current Network

Understanding the Problem

Method 1 — Edit Wi-Fi Credentials Directly from the SD Card (Best Method)

Step 1 — Remove the SD Card

Step 2 — Open the Boot Partition

Step 3 — Create or Edit wpa_supplicant.conf

Why country=NG Matters

Step 4 — Enable SSH

Step 5 — Reinsert SD Card and Boot

Step 6 — Find the Raspberry Pi on the Network

Option A — Use Fing (Recommended)

Option B — Use Router Admin Page

Option C — Use ping

Step 7 — SSH Into the Pi

What If You Don’t Know the Username?

Method 2 — Reflash Using Raspberry Pi Imager (Cleanest Option)

Install Raspberry Pi Imager

Configure Headless Setup Properly

General

Services

Troubleshooting Tips

1. Pi Not Appearing on Network

2. SSH “Hostname Could Not Be Resolved”

3. SSH Connection Refused

4. Raspberry Pi Only Supports 2.4GHz

Bonus Tip — Use Your Phone Hotspot

Recommended Headless Workflow

During OS Imaging

Keep Backup Notes

Use Static Hostnames

Final Thoughts

API Keys vs. Access Tokens: What's the Real Difference?

🔑 The API Key: The "Project ID Card"

🎟️ The Access Token: The "Visitor Badge"

📊 Side-by-Side Comparison

💡 When to use which?

Use an API Key when:

Use an Access Token when:

🛡️ Pro-tip: Never Hardcode!

🚀 Setting Up Raspberry Pi & Camera for AI Projects (Complete Command Guide)

🧠 1. System Setup & Updates

🌐 2. Network & IP Configuration

Check IP address

🔐 3. Remote Access Setup

Enable SSH and VNC

Connect via SSH

🖥️ 4. VNC (Remote Desktop Access)

Steps:

📸 5. Camera System (Important Update)

🧪 6. Test Camera

Preview camera

Capture image

Record video

📂 7. File Management Commands

List files

Create folder

🔁 8. Capture Multiple Images

🖼️ 9. Open Image (on Raspberry Pi GUI)

🧪 10. Python + OpenCV Setup

Start Python

Import OpenCV

Load image

Resize image

Convert to grayscale

Convert to HSV

Exit Python

⚠️ 11. Common Troubleshooting

Camera not working?

No preview?

Restart system

🧠 Key Takeaways

🎯 Final Thoughts

🔥 If you found this useful

COMPLETE COURSE: Git & GitHub (From Zero to Advanced)

📘 COURSE OVERVIEW

🧩 MODULE 1: WHAT IS GIT?

🔹 Definition

🔹 Key Features

🔹 Real-world Problem Git Solves

Step 3 — Create or Edit `wpa_supplicant.conf`

Why `country=NG` Matters

Option C — Use `ping`