DEV Community: Ernest Kabahima

# 🛠️ Fixing “No Valid Android SDK Root Found” Error in WSL (Ubuntu)

Ernest Kabahima — Thu, 13 Nov 2025 17:05:35 +0000

When developing Android or Ionic apps inside WSL (Windows Subsystem for Linux), you might hit this frustrating error:

[ERROR] Error while getting native targets for android: No valid Android SDK root found.

This usually happens when running:

npm run dev:android
ionic cap run android
ionic cordova run android

Don’t worry — it’s a common issue when working across Windows and WSL.
Here’s what causes it and how to fix it cleanly.

Why This Happens

There are two main culprits behind this error:

1. WSL Can’t See the Android SDK

Your Android SDK is installed on Windows, not inside WSL.
Typically, it lives here:

C:\Users\<Your-Username>\AppData\Local\Android\Sdk

In WSL, that same folder appears under:

/mnt/c/Users/<Your-Username>/AppData/Local/Android/Sdk

However, if your Windows username contains a space (like FIRST NAME), Linux treats it as two separate paths unless you quote it properly.
That’s why the Android build tools inside WSL can’t find your SDK.

2. Missing Android Command-Line Tools

Even if the SDK path is correct, you might still lack the essential Android tools (sdkmanager, avdmanager, etc.) that WSL needs to manage devices and builds.
Without these, the SDK can’t be validated — hence the “no valid SDK root” message.

Step-by-Step Fix

Follow these steps in your WSL terminal 👇

1. Set Correct Android SDK Paths

Run these commands (replace your username if needed):

echo 'export ANDROID_HOME="/mnt/c/Users/Ernest Kabahima/AppData/Local/Android/Sdk"' >> ~/.bashrc
echo 'export ANDROID_SDK_ROOT="$ANDROID_HOME"' >> ~/.bashrc
echo 'export PATH="$PATH:$ANDROID_HOME/emulator:$ANDROID_HOME/platform-tools:$ANDROID_HOME/cmdline-tools/latest/bin"' >> ~/.bashrc
source ~/.bashrc

Confirm the path:

echo $ANDROID_HOME

You should see:

/mnt/c/Users/Ernest Kabahima/AppData/Local/Android/Sdk

2. Install Android Command-Line Tools

If sdkmanager isn’t recognized, install it with:

sudo apt update
sudo apt install google-android-cmdline-tools-11.0-installer -y

This installs the latest command-line tools inside /usr/lib/android-sdk/.

3. Link WSL Tools to Your Windows SDK

Make sure your Windows SDK has the proper structure:

mkdir -p "/mnt/c/Users/Ernest Kabahima/AppData/Local/Android/Sdk/cmdline-tools/latest"
sudo ln -s /usr/lib/android-sdk/cmdline-tools/* "/mnt/c/Users/Ernest Kabahima/AppData/Local/Android/Sdk/cmdline-tools/latest/"

Now WSL and Windows share the same SDK tools.

4. Accept SDK Licenses

This ensures the tools can run properly:

yes | sdkmanager --licenses

5. Verify Your Setup

Check versions and SDK content:

adb version
sdkmanager --list | head -20

If both work, your SDK is ready.

6. Run Your Project Again

Now re-run your dev command:

npm run dev:android

If you still get a native-run error, use:

npm run dev:android -- --no-native-run

That tells the system to fall back to Cordova’s runner.

Quick Recap

Problem	Cause	Fix
No valid Android SDK root	WSL can’t find Windows SDK	Use quoted path `/mnt/c/...`
sdkmanager not found	Missing SDK tools	`sudo apt install google-android-cmdline-tools-11.0-installer`
native-run errors	Emulator or device not found	Start emulator or use `--no-native-run`

Bonus Tip: Avoid Spaces in SDK Paths

If possible, move your Android SDK to a path without spaces, such as:

C:\Android\Sdk

Then update your environment variables accordingly.
This avoids quoting issues entirely and makes WSL integration smoother.

Conclusion

This issue boils down to two things:

WSL not interpreting Windows paths with spaces
Missing command-line tools for Android builds

By setting your environment variables properly and installing the SDK tools, you can run and build Android apps inside WSL just like a native Linux environment — no more “No valid Android SDK root” headaches.

"Exploring Top MLOps Platforms for Efficient Machine Learning Lifecycle Management"

Ernest Kabahima — Fri, 31 Jan 2025 14:50:58 +0000

These platforms help with automating and streamlining various stages of the machine learning lifecycle, from development to deployment and monitoring, and many integrate with popular cloud services like AWS, Google Cloud, and Azure. The choice of platform depends on specific needs such as scalability, integration with existing tools, and the complexity of the machine learning operations.

There are several MLOps platforms available, each catering to different aspects of machine learning lifecycle management, such as model development, deployment, monitoring, and governance. Here are some of the popular MLOps platforms:

Kubeflow

An open-source platform designed to facilitate the development, deployment, and monitoring of machine learning models on Kubernetes.
Key Features:

Supports end-to-end pipelines.
Model training, serving, and monitoring.
Built on Kubernetes for scalability.

MLflow

An open-source platform for managing the complete machine learning lifecycle, including experimentation, reproducibility, and deployment.
Key Features:

Experiment tracking.
Model versioning and packaging.

Model deployment.

TensorFlow Extended (TFX)

An end-to-end platform for deploying production machine learning pipelines using TensorFlow.
Key Features:

Model training, evaluation, and deployment.
Data validation and transformation.
Model monitoring and versioning.

Seldon

A platform focused on deploying, monitoring, and managing machine learning models at scale.
Key Features:

Model deployment and scaling.
Model monitoring and explainability.
Integrates with Kubernetes and supports many model types.

Amazon SageMaker

A fully managed service by AWS that provides an integrated environment for developing, training, and deploying machine learning models.
Key Features:

Managed Jupyter notebooks.
Automated hyperparameter tuning.
End-to-end deployment and monitoring.

Azure ML

A cloud-based platform from Microsoft Azure for building, training, and deploying machine learning models.
Key Features:

Experiment tracking.
Automated ML and hyperparameter tuning.
Model deployment and monitoring.

Google AI Platform

A cloud-based machine learning platform by Google that helps with building and deploying models at scale.
Key Features:

Integration with TensorFlow and other ML frameworks.
Model deployment and monitoring.
Automated machine learning.

Databricks

A cloud platform that provides collaborative notebooks and unified analytics for data engineering and machine learning.
Key Features:

Managed Spark clusters for scalable ML.
Collaborative notebooks for team development.
Integration with MLflow for managing models.

Comet.ml

An experiment tracking platform for machine learning, focused on collaboration, model versioning, and visualization.
Key Features:

Tracking and visualizing experiments.
Model and dataset versioning.
Collaboration for teams.

Weights & Biases (W&B)

A platform for tracking experiments, visualizing results, and managing datasets and models.
Key Features:

Experiment tracking and visualization.
Model versioning.
Collaborative team features.

DataRobot

An enterprise AI platform that automates machine learning and helps with model deployment and monitoring.
Key Features:

Automated model training and selection.
Model monitoring and deployment.
Interpretability and explainability features.

MLflow

A popular open-source platform for managing the machine learning lifecycle, especially for tracking experiments and managing models.
Key Features:

Experiment tracking.
Model packaging and versioning.

Model deployment and serving.

Flyte

An open-source workflow orchestration platform that supports building, deploying, and managing ML workflows.

Key Features:

Supports batch and streaming data workflows.
Scalable orchestration and execution.
Built-in integrations with ML frameworks like TensorFlow and PyTorch.

Pachyderm

An open-source data versioning platform designed for machine learning workflows.
Key Features:

Data lineage tracking.
Scalable ML pipelines.
Version-controlled data for reproducibility.

Polyaxon

A platform for building, training, and deploying machine learning and deep learning models.
Key Features:
Experiment tracking and model versioning.
Scalable deployment.
Kubernetes-native architecture.

How to Safeguard Against Disruptions from Data Schema Changes

Ernest Kabahima — Fri, 31 Jan 2025 14:00:41 +0000

Data schema changes are inevitable as applications grow and evolve. However, if not handled properly, they can lead to broken functionality, data loss, or downtime. To prevent these disruptions, developers must follow a structured approach that ensures seamless transitions while maintaining data integrity. Below, we discuss key strategies to safeguard against disruptions caused by schema changes.

Use Migrations Instead of Direct Changes

Making direct changes to a live database, such as adding or removing columns manually, can be risky. Instead, developers should use database migration tools that provide a structured way to apply and track schema changes. Some popular migration tools include:

Alembic (for SQLAlchemy/Python)
Flyway (for various databases including PostgreSQL and MySQL)
Liquibase (for version-controlled database changes)
Knex.js (for Node.js applications)

These tools allow for version control, rollback options, and a safer way to update the database without disrupting the application.

Make Schema Changes Backward-Compatible

Ensuring backward compatibility is crucial when updating a database, especially in production environments. Backward-compatible changes allow existing functionalities to continue working while transitioning to the new schema. Some key practices include:

Adding new fields without removing old ones immediately to prevent breaking queries.
Using default values when adding new columns to avoid unexpected NULL values.
Gradually phasing out deprecated fields only after all application parts are updated.
Implement API and Database Versioning
Versioning ensures different parts of the system remain compatible during schema transitions.
Database versioning: Use version numbers or timestamps for database migrations to track and roll back changes if needed.
API versioning: Create new API versions (e.g., /v2/products) instead of modifying existing ones immediately.
Grace periods: Allow clients time to adapt before deprecating older versions.
Automate Testing & Schema Validation
Testing prevents unexpected errors before rolling out schema changes.
Schema validation tools (e.g., JSON Schema) ensure data adheres to the expected format.
Automated database tests in CI/CD pipelines detect issues before deployment.
Load testing helps assess performance impact from schema modifications.

Maintain Database Backups & Audits

Despite careful planning, things can go wrong. Regular backups and audit logs help mitigate risks.Perform full backups before applying schema modifications for quick recovery.

Use point-in-time recovery for databases that support it. Maintain an audit trail to track schema changes and modifications.

Implement Feature Flags for Schema-Dependent Features : Feature flags allow gradual rollout of new database features instead of immediate deployment.

Use feature toggles to enable or disable schema-dependent features dynamically.

Test schema updates in a staging environment before full deployment.

Roll back changes easily by disabling the feature flag rather than modifying the database directly.

Document Schema Changes Clearly

A lack of documentation can lead to confusion and errors when working with evolving schemas. To ensure team members understand the changes:

Maintain a schema changelog recording each modification, its purpose, and impact.

Update API and database documentation to reflect new structures.

Communicate changes with stakeholders to avoid misalignment.

Test Schema Changes in a Staging Environment

Before deploying schema changes to production, always test them in a staging environment that mirrors production.

Replicate real-world data scenarios to assess potential impacts.

Ensure application compatibility with the new schema before final deployment.

Monitor query performance to detect slow queries introduced by schema modifications.

Overcoming Resistance to Change in Database Scalability

Resistance to change is common when implementing database scalability improvements. However, ensuring a smooth transition requires effective strategies:

Communicate the vision: Clearly articulate the benefits of scalable databases to all stakeholders.

Provide training: Offer comprehensive support and education on the new systems and processes.

Showcase quick wins: Demonstrate immediate improvements to motivate and build confidence in the changes.

By addressing concerns early and involving stakeholders in the process, resistance can be minimized, and scalability efforts can succeed without unnecessary delays.

Final Thoughts

Database schema changes are necessary for evolving applications, but they must be managed carefully to prevent disruptions. By using migrations, ensuring backward compatibility, automating testing, maintaining backups, implementing feature flags, and documenting changes, developers can minimize risks and ensure smooth transitions. Proper planning and a structured approach help safeguard against potential issues, ensuring that schema changes do not negatively impact the system or its users. Additionally, addressing resistance to change through effective communication, training, and showcasing quick wins will ensure scalability improvements are adopted smoothly.

Simple Event Registration API with MongoDB and Flask

Ernest Kabahima — Thu, 28 Nov 2019 06:30:17 +0000

let's start

Simple Event Registration API is a demonstration of how to create, read and write data with MongoDB using Flask

MongoDB

MongoDB is a document database with the scalability and flexibility that you want with the querying and indexing that you need. Its document model is simple for developers to learn and use, while still providing all the capabilities needed to meet the most complex requirements at any scale but You can get started here

Use cases for MongoDB include the following;

To install MongoDB Click here if not installed

Flask

Flask is a micro web framework written in Python. It is classified as a microframework because it does not require particular tools or libraries.

If you are new to python and Flask You can get started here with the following articles
first, get to understand python secondly start playing with Flask

Postman

This is a tool that makes the game of building API's fun, its a must-have before even thinking of building an API. Postman is currently one of the most popular tools used in API testing. It started in 2012 as a side project by Abhinav Asthana to simplify API workflow in testing and development.

API stands for Application Programming Interface which allows software applications to communicate with each other via API calls.

More about APIs Click Here

Set up

Install python on your machine if not installed you can check by using the following command python3 --version
check if the virtual environment is installed if not install it Linux for Windows

1.Create Virtual environment

python3 -m venv venv

venv - means the name of the virtual environment it can be anything
Read More

2.Activate Virtual environment

source venv/bin/activate or . venv/bin/activate

2.Installing the following

Flask
pip install flask
Pymongo
pip install pymongo
check using pip list

Create a file called app.py with the following command Touch app.py
paste the following code

from flask import Flask, jsonify, request
from flask_pymongo import PyMongo

app = Flask(__name__)
app.config["MONGO_URI"] = "mongodb://localhost:27017/regdb"
mongo = PyMongo(app)


@app.route('/', methods = ['GET'])
def get_all_attendees():
"""To get all the items from the database.its a Get request and we use the databasename.find()"""
    attendees = mongo.db.attendees
    output = []

    for r in attendees.find():
        output.append({
                    'name':r['name'],
            'address':r['address'],
                    'Phone_Number':r['p_number']
                    })
    return jsonify({'result' : output})

@app.route('/attendee/<name>', methods = ['GET'])
def get_one_attendee(name):
"""To get one item from the database.its a Get request and We use the databasename.find_one"""
    attendees = mongo.db.attendees
    attendees.find_one({'name':name})

    output.append({
                    'name':r['name'],
            'address':r['address'],
                    'Phone_Number':r['p_number']
                    })
    return jsonify({'result' : output})

@app.route('/register', methods = ['POST'])
def register():
"""To add an item to the database. its a post request and we use databasename.insert()"""
    attendees = mongo.db.attendees
    name = request.json['name']
    language=request.json['language']
    reg_id = attendees.insert({
                    'name':r['name'],
            'address':r['address'],
                    'Phone_Number':r['p_number']
                    })
    r = attendees.find_one({'_id':reg_id})
        output = ({
                    'name':r['name'],
            'address':r['address'],
                    'Phone_Number':r['p_number']
                    })
        return jsonify({'result' : output})

if __name__== '__main__':
    app.run(debug=True)

Go ahead and test your API with Postman

Thanks, Ernest

DEV Community: Ernest Kabahima

# 🛠️ Fixing “No Valid Android SDK Root Found” Error in WSL (Ubuntu)

Why This Happens

1. WSL Can’t See the Android SDK

2. Missing Android Command-Line Tools

Step-by-Step Fix

1. Set Correct Android SDK Paths

2. Install Android Command-Line Tools

3. Link WSL Tools to Your Windows SDK

4. Accept SDK Licenses

5. Verify Your Setup

6. Run Your Project Again

Quick Recap

Bonus Tip: Avoid Spaces in SDK Paths

Conclusion

"Exploring Top MLOps Platforms for Efficient Machine Learning Lifecycle Management"

Kubeflow

MLflow

TensorFlow Extended (TFX)

Seldon

Amazon SageMaker

Azure ML

Google AI Platform

Databricks

Weights & Biases (W&B)

DataRobot

MLflow

Flyte

Pachyderm

Polyaxon

How to Safeguard Against Disruptions from Data Schema Changes

Use Migrations Instead of Direct Changes

Make Schema Changes Backward-Compatible

Maintain Database Backups & Audits

Document Schema Changes Clearly

Simple Event Registration API with MongoDB and Flask

let's start

MongoDB

Use cases for MongoDB include the following;

Flask

Postman

Set up

1.Create Virtual environment

2.Activate Virtual environment

2.Installing the following