DEV Community: Yousaf Khalil

How I Built a Visioryx Forensic Engine with FastAPI and BLIP 🛡️

Yousaf Khalil — Fri, 06 Mar 2026 18:10:51 +0000

Most AI image captioners just tell you what is in the picture. I wanted to build something deeper. I built Visioryx to bridge the gap between Neural Scene Intelligence and Digital Hardware Forensics.
Key Engineering Wins:

Multimodal Analysis: Integrated the Salesforce/blip-image-captioning-base model to transform pixels into descriptive natural language.

Metadata Recovery: Engineered a Python-based forensic layer using PIL to extract hidden EXIF headers (Camera Model, ISO, Aperture).

The "Scrubbed Data" Problem: One of my biggest challenges was handling images from platforms like Unsplash or Facebook that strip metadata. I implemented a fallback logic that identifies "Data Stripping" as a forensic state rather than a system failure.

Full-Stack Utility: Designed a custom Glassmorphic UI and an automated PDF report generator for professional hand-offs.

The Stack:

Backend: FastAPI / Uvicorn

AI Logic: PyTorch / Transformers

Frontend: Tailwind CSS

Live Demo: https://huggingface.co/spaces/yousafk279/Visioryx
Open Source: https://github.com/yousafk279/visioryx

How I Solved the "API Cost" Problem with a Dual-Mode Engine in FastAPI

Yousaf Khalil — Tue, 24 Feb 2026 21:31:15 +0000

The Problem
Like many developers building portfolio projects, I wanted to integrate the Twilio SMS API. However, I faced two hurdles: 1) Managing API costs and 2) Ensuring my project remained functional for recruiters even if my credentials were inactive.

The Solution: The Dual-Mode Architecture
Instead of letting the app crash, I engineered a logic gate using Python's os.getenv.

if SID and TOKEN and NUMBER:
# Real API logic
else:
# Demo Mode logic

Key Features I Implemented:

State Simulation: In Demo Mode, the backend uses asyncio.sleep to simulate network latency, providing a high-fidelity experience.

Local Persistence: Every message—demo or real—is committed to a local SQLite database to ensure an audit trail exists.

Data Portability: I added a StreamingResponse endpoint to export database logs as a CSV file directly to the user's machine.

UI Polish: As a Graphic Designer, I couldn't settle for a basic form. I used Tailwind CSS to build a glassmorphism "Cyberpunk" console that reflects the high-stakes nature of a dispatch system.

python #fastapi #webdev #showdev #api #coding

Building a Resilient Financial Engine: How I Fixed a Data Duplication Bug with Idempotent SQL

Yousaf Khalil — Sat, 21 Feb 2026 13:48:16 +0000

Most developers hide their bugs. I prefer to document them.

I recently built a full-stack financial dashboard to track budgets and spending. The goal was simple: connect a Python backend to a SQLite3 database and render the output dynamically on a web interface.

But during testing, I hit a massive logic failure. My migration script was blindly inserting data every time it ran. Instead of my actual balance, my dashboard rendered a massive deficit of $-460.0

Here is exactly how I refactored the database logic to enforce data integrity and deployed the final application to the cloud.

The Tech Stack
Backend: Python
Database: SQLite3
Frontend: HTML5 / CSS3
Hosting: Hugging Face Spaces

The Problem: Blind Data Insertion
Initially, my Python script was executing simple INSERT statements without checking if the record already existed. Every time the app initialized, it duplicated the transactions. In a financial application, bad data is worse than a crashed app. A $-460.0 balance on a $500 budget meant my core logic was fundamentally broken.

The Fix: Idempotency
To fix this, I had to implement Idempotency the concept that an operation can be applied multiple times without changing the result beyond the initial application.

I updated my SQL execution logic. Instead of blindly inserting data, I leveraged UNIQUE constraints and INSERT OR IGNORE (or IF NOT EXISTS for table creation) in SQLite3.

By forcing the database engine to handle the validation, I eliminated the duplication at the source. The application could now restart 100 times, and the data would remain perfectly accurate.

The Result: A Cloud-Hosted Source of Truth
Once the backend logic was secured, the dashboard immediately reflected the verified, mathematically correct balance of $180.0.

I then packaged the application and deployed it live via Hugging Face Spaces, ensuring standard UTF-8 encoding so the UI rendered cleanly across all browsers.

Live Links & Code
I’m a big believer in building in public. You can review the idempotent logic in my repository or test the live dashboard yourself.

💻 Review the Source Code: https://github.com/yousafk279/Life-Manager-SQL-Engine
🚀 Test the Live Dashboard: https://huggingface.co/spaces/yousafk279/Financial-Integrity-Dashboard

If you're building data-driven applications, never trust your initial migration scripts. Enforce idempotency at the database level.

Let me know in the comments how you handle data validation in your own Python projects!