DEV Community: Afee Muhammod Wafy

Building Doseleaf: An Offline-First Medicine Reminder App with Kotlin and Jetpack Compose

Afee Muhammod Wafy — Sat, 24 Oct 2026 18:49:37 +0000

Medication management can become complicated when someone needs to track multiple medicines, follow different schedules, and maintain a reliable history of doses.

To address this problem, I developed Doseleaf, an offline-first Android application designed to make medicine scheduling and medication record-keeping more organised.

Doseleaf is a product of Wafyro Software, developed by Afee Muhammod Wafy.

The project focuses on native Android development, local data persistence, scheduled reminders, and practical data-management workflows.

Explore Doseleaf:

Website: doseleaf.amwafy.xyz
Source code: GitHub Repository

What Is Doseleaf?

Doseleaf is a native Android application built with Kotlin and Jetpack Compose. It provides a central place to manage medicines, organise schedules, maintain dose history, and handle related records.

The application includes:

Medicine creation and editing
Multiple daily reminder times
Family profiles for organising medication records
Dose history with Taken and Skip actions
Reminder notifications and alarm interactions
Medicine recovery through a Recycle Bin
Local JSON backup and restore
CSV dose-history export and PDF reports
Inventory management and expiry-date handling

One of the core design goals is to keep the main medication-management workflow local-first, without requiring a backend account for ordinary use.

Tech Stack

Doseleaf uses native Android technologies rather than a cross-platform UI framework.

Technology	Purpose
Kotlin	Primary programming language
Jetpack Compose	Declarative UI
Material 3	UI components and visual design
Room	Structured local database
SQLite	Persistent data storage
Kotlin Coroutines and Flow	Asynchronous operations and observable state
Android AlarmManager	Scheduled reminders
BroadcastReceiver	Reminder events and system broadcasts
DataStore Preferences	Preference storage
Storage Access Framework	User-initiated file export and restore
FileProvider	Controlled sharing of app-managed files

The project targets Android SDK 35, supports Android API 26 and above, and uses Java 17 compatibility.

Architecture: A Local-First Android Application

Doseleaf combines three main areas of responsibility.

1. UI layer

Jetpack Compose renders the application interface. The main UI entry point is DoseleafApp.kt, which contains the application navigation, screen composables, and DoseleafViewModel.

2. Data layer

Room provides structured persistence through entities and Data Access Objects (DAOs).

The database includes five entity types:

FamilyProfileEntity
MedicineEntity
MedicineScheduleEntity
DoseLogEntity
InventoryEntity

These represent family profiles, medicines, schedules, dose history, and inventory records.

3. Android integration layer

Dedicated components handle reminder scheduling, notification delivery, alarm interactions, and restoration of scheduled reminders following device reboot or relevant system time changes.

Keeping these responsibilities organised makes the codebase easier to reason about and maintain.

Designing the Database

Medication management involves more than storing medicine names and reminder times.

The application must associate medicines with profiles, support multiple schedules, preserve historical activity, and handle deletion and restoration.

Doseleaf separates medicine records from schedule records. A single medicine can have multiple associated schedule entries, allowing different reminder times without duplicating the medicine itself.

Dose history is stored separately in dose_logs. The log entity also stores a medicine-name snapshot, helping preserve historical context when the current medicine record changes.

The database is currently at schema version 5 and includes explicit migrations from earlier versions.

This highlights an important lesson in Android development: database changes must account for existing installations and their stored data, not just the latest application schema.

Implementing Medication Reminders

Reminder reliability is one of the most interesting engineering challenges in Doseleaf.

The application uses Android's AlarmManager to request scheduled reminder events. The main scheduling logic lives in ReminderScheduler.kt, while ReminderReceiver.kt handles reminder delivery.

The general workflow is:

Read the enabled schedule entries from the local database.
Calculate the next occurrence for each schedule.
Create a PendingIntent associated with the relevant medicine and schedule.
Request an exact alarm when the required access is available.
Fall back to an inexact alarm when exact-alarm access is unavailable.
Handle the event and expose the available dose actions.

The project also includes a BootReceiver to handle device reboot and system time or time-zone changes.

Android's background execution policies make this more complicated than simply scheduling a callback. Exact-alarm access, notification permissions, battery-management behaviour, and device-specific restrictions can all affect the result.

Doseleaf includes fallback scheduling behaviour, but reminder delivery still requires validation across supported Android versions and physical devices.

Preventing Duplicate Dose Records

A notification action can be triggered more than once. Users may tap repeatedly, or multiple events may attempt to record the same scheduled occurrence.

Doseleaf uses a coroutine Mutex around dose logging and checks existing records before inserting another entry for the same medicine and scheduled timestamp.

The objective is to make repeated actions idempotent for a scheduled occurrence.

This is a useful general engineering principle: preventing duplicate operations requires attention to the persistence layer, not merely disabling a UI button.

Further automated testing is needed to establish the behaviour under concurrent events, process recreation, and other edge cases.

Family Profiles and Data Integrity

Doseleaf supports multiple family profiles to organise medication records by person.

The default profile is protected against deletion. When another profile is deleted, the application cancels the associated medicine reminders, processes related medicines through its deletion workflow, and retains dose history.

The Recycle Bin provides a recovery path before permanent deletion.

These workflows illustrate why deleting a database record is rarely an isolated operation. Related records, scheduled alarms, and historical data must be considered together.

Backup, Restore, and Export

Local-first applications also need a practical way to protect and retrieve user data.

Doseleaf supports:

JSON backup and restore
CSV dose-history export
Date-range PDF reports

The JSON backup includes profiles, medicines, schedules, dose logs, and inventory records. The restore implementation validates the backup format, supported schema versions, and important relationships before replacing database contents within a Room transaction.

Prescription-photo data can also be embedded in a backup when the source file is accessible and satisfies the implementation's size limit.

For exporting and restoring files, the application uses Android's document APIs, allowing users to choose an available destination. A compatible cloud-storage document provider may be used as a destination, but this is manual file export rather than automatic cloud synchronisation.

Backup and restore workflows deserve careful testing because malformed files, incompatible versions, and interrupted operations can threaten data integrity.

Engineering Lessons from Doseleaf

Building Doseleaf brings together several practical Android engineering concerns.

Data persistence requires lifecycle planning. Schema migrations, historical records, deletion, restoration, and backup compatibility must work together.

Background execution is platform-dependent. Android APIs provide mechanisms for requesting scheduled work, but permissions and operating-system policies influence delivery.

Duplicate actions are data-integrity problems. A reliable solution must consider concurrent operations and existing database records.

Offline-first does not eliminate data-loss risks. Local persistence reduces dependence on remote services, but backup and restore become particularly important.

Implemented does not automatically mean verified. A feature's source code, successful builds, automated tests, and real-device behaviour are different stages of engineering.

These considerations have shaped how I approach application architecture and reliability.

Current Status and Areas for Improvement

Doseleaf is an ongoing development project. The current source snapshot has not yet been verified through a complete successful build and comprehensive real-device QA cycle.

Important next steps include:

Validating reminder delivery and reboot restoration across supported Android versions
Testing notification and exact-alarm permission flows
Expanding automated tests for database operations and duplicate dose actions
Testing database migrations against existing installations
Strengthening backup and restore failure handling
Completing and validating Bangla localisation
Testing battery-management behaviour across device manufacturers

Doseleaf is intended for medication scheduling and record-keeping. It does not determine medically appropriate doses or replace professional medical advice.

About Wafyro Software

Wafyro Software is the product organisation behind Doseleaf.

Doseleaf is developed by Afee Muhammod Wafy, with a focus on native Android engineering, maintainable architecture, and practical user-facing software.

You can explore the project through the following official links:

Product website: https://doseleaf.amwafy.xyz
GitHub repository: https://github.com/afeemuhammodwafy1/doseleaf

The project is licensed under the MIT License.

Feedback, bug reports, and contributions that improve reliability, maintainability, accessibility, and user experience are welcome.

When reporting issues, please include relevant technical details such as the Android version, device manufacturer, and error logs. Avoid sharing real prescriptions, personal health records, or identifying patient information in public issues.

What's Next?

The next priorities are expanding automated test coverage, validating reminder behaviour on physical devices, strengthening database and restore workflows, and completing localisation.

I would particularly appreciate feedback from Android developers who have worked with AlarmManager, notification permissions, Room migrations, and offline-first architectures.

If you have built an application with similar constraints, what engineering challenges did you find most difficult?

You can explore Doseleaf and follow its development here:

Website: doseleaf.amwafy.xyz

Source code: github.com/afeemuhammodwafy1/doseleaf

I Built Afey Tabs to Stop Losing My Browser Tabs

Afee Muhammod Wafy — Wed, 21 Oct 2026 17:04:50 +0000

I Built Afey Tabs to Stop Losing My Browser Tabs

Have you ever opened your browser to work on one thing, only to end up with dozens of tabs open?

Documentation, GitHub issues, tutorials, dashboards, research pages—and somehow, all of them feel important.

Closing the browser feels risky. Keeping everything open makes it harder to focus. And when you need to return to a specific task later, finding the right group of tabs can become a task of its own.

I wanted a simpler way to handle this problem, so I built Afey Tabs.

🔗 Try it: https://afeytabs.amwafy.xyz

What is Afey Tabs?

Afey Tabs is a Chrome extension that helps you save related browser tabs into named workspaces and restore them when you need them again.

The idea is simple: instead of keeping every tab open all day, save the tabs related to a task and return to them later.

For example, you could create workspaces such as:

Web Development — documentation, GitHub, and testing tools
Learning — tutorials, articles, and course materials
Research — references, reports, and useful resources
Personal Projects — the pages you need for your next coding session

Each workspace gives those tabs a place to belong.

What can it do?

Afey Tabs focuses on a small set of practical features:

Save tabs: Save eligible tabs from your current browser window.
Choose what to save: Select specific eligible tabs or save all eligible tabs.
Create named workspaces: Organize saved tabs around projects or tasks.
Add a note: Keep one optional, editable note with each workspace.
Restore tabs: Reopen the saved tabs when you're ready to continue.
Manage workspaces: Delete workspaces you no longer need.
Export a backup: Export your workspace data as JSON.

It is intentionally focused on doing one job: helping you keep your browsing organized so you can return to your work more easily.

Privacy matters

I wanted Afey Tabs to keep its data handling straightforward.

Workspace data is stored locally in the browser using chrome.storage.local. The extension does not require an Afey Tabs account or a cloud-sync service.

You can also export your workspace data as a JSON backup.

One important note: local storage is not the same as encryption. Exported backups may contain the URLs and notes you've saved, so keep those files somewhere appropriate.

Why build another productivity tool?

There are plenty of productivity apps already.

But sometimes, I don't need a full task manager or another place to manage my projects. I just need to save the browser context I was working in and come back to it later.

That is the problem Afey Tabs is designed to address.

I also wanted to build something focused, useful, and small enough to improve through real feedback rather than adding features just for the sake of having them.

What's next?

I'm sharing Afey Tabs with the developer community to get feedback and learn how people actually organize their browser sessions.

I'd love to hear from you:

How do you manage browser tabs when working on multiple projects?
Do you use separate browser profiles, bookmarks, tab groups, or another tool?
What would make a lightweight workspace manager more useful to you?

If you try Afey Tabs, let me know what works for you and what could be better.

🔗 Afey Tabs: https://afeytabs.amwafy.xyz

💻 Source code: https://github.com/afeemuhammodwafy1/afeylabs

I'm Afee Muhammod Wafy, founder and software developer at Wafyro Software. Thanks for reading!

Building Wafyro Software: Why We’re Focused on Practical Software & Web Applications

Afee Muhammod Wafy — Sun, 04 Oct 2026 06:03:34 +0000

Building Practical Software at Wafyro Software

Software does not always need to be complicated to be useful.

Sometimes, the best software is the software that solves a small, real-world problem reliably—and stays out of the user's way.

That idea is one of the reasons I'm building Wafyro Software.

Wafyro Software is an independent software development initiative where I build and publish practical software products and web applications designed to solve real problems without adding unnecessary complexity.

Why Wafyro Software?

Many software products are technically impressive but unnecessarily complicated for the people they are meant to serve.

I want to take a different approach.

My focus is on a few core principles:

Solve a real problem first.
Keep the user experience simple.
Make important data understandable and portable.
Minimize unnecessary dependencies.
Consider privacy from the beginning.
Build systems that can evolve without becoming difficult to maintain.

This philosophy became much clearer while building my first public application, Hishab Ledger.

Hishab Ledger: A Small Problem With Real Users

Hishab Ledger is an Android application designed for personal and small-business hisab, due, and payment tracking.

The problem is simple.

People often need to remember:

Who owes them money.
How much is currently due.
When a payment was made.
How much has been added over time.
What the transaction history looks like.

A spreadsheet can solve some of these problems. A generic accounting system can solve many more.

But both can be unnecessarily complicated for someone who simply wants to track everyday dues.

So I focused on building the smallest useful system that addresses these needs.

Offline-First by Design

One of the most important architectural decisions in Hishab Ledger was making its core experience offline-first.

The application does not require an account for its core functionality. Records are stored locally on the device, allowing users to manage their data without depending on a network connection.

This changes how I approach application architecture.

Instead of assuming:

User → Internet → Server → Database

the application can work around:

User → Local Data → Local Operations

This makes the basic experience more predictable.

No connection?

The core ledger still works.

For applications that handle everyday records, availability should not depend unnecessarily on network connectivity.

Data Should Be Portable

Local storage alone is not enough.

If important data exists only inside an application, users can eventually become dependent on that application.

That's why Hishab Ledger includes data portability features such as:

JSON backup and restore.
Replace and Merge restore workflows.
Full CSV export.
Shop-wise CSV export.
PDF statements.
Shareable transaction summaries.

The principle is simple:

Your data should remain useful outside the UI that created it.

I want to carry this principle into future Wafyro Software products as well.

Keeping the Ledger Simple

Hishab Ledger revolves around a relatively small set of concepts.

People and Shops

Users can maintain records for people and shops, including optional contact information.

Due and Payment Transactions

A transaction can represent either an amount added to the due or a payment.

Each transaction can include:

Amount.
Date and time.
Optional note.

Opening Balance

Real-world records rarely start at zero.

An opening balance allows users to begin with an existing outstanding amount instead of reconstructing their entire history just to get the current balance right.

Statements

A shop's current position can be turned into a PDF statement or a shareable summary.

The goal is not to expose every internal detail to the user.

The goal is to make the information useful when they need it.

Small Features Matter

Some of the most useful features aren't necessarily the most impressive ones.

Hishab Ledger includes:

Undo after deletion.
Recently Deleted records.
Local reminders and notifications.
PIN and biometric app locking.
Today's transaction summary.
Search.
Multiple shops.
Quick phone actions.

I approach these features by thinking about actual usage rather than simply building a feature checklist.

For example, deletion is not just a database operation.

From a user's perspective:

"I deleted something by mistake."

That's why undo and Recently Deleted matter.

Good software often comes from noticing these small moments and designing for them.

Privacy as an Architectural Decision

Privacy is easier to talk about than to implement.

For applications dealing with financial or personal records, an important question is:

Where does the data actually go?

With an offline-first design, Hishab Ledger can keep its core records locally on the user's device rather than requiring a remote, account-based architecture for basic usage.

That doesn't automatically solve every security problem.

Local data still needs appropriate protection, careful backup handling, device security, and sound application design.

But reducing unnecessary data transmission is a meaningful starting point.

I want privacy to be a design consideration from the beginning, not something added after the core system has already been built.

What I'm Learning

Building and maintaining a practical application has taught me something important:

Constraints improve software.

When I decide that an application should be simple, offline-first, private, portable, and easy to understand, every architectural decision becomes more meaningful.

I have to ask whether a feature actually improves the product.

I have to think about failure cases.

I have to consider how users recover from mistakes.

And I have to decide what should happen when the network, server, or an external dependency is unavailable.

These are not just product decisions.

They are engineering decisions.

Working independently also means taking responsibility for multiple parts of the development process, from implementation and debugging to deployment and maintenance.

That experience is helping me understand software development beyond simply writing code.

Where Wafyro Software Is Going

Hishab Ledger is only one part of what I want to build.

The broader direction of Wafyro Software is to develop practical, focused software products and web applications around real user needs.

I'm interested in exploring different types of software, understanding how people actually use them, and gradually building systems that become more capable without becoming unnecessarily complex.

My areas of interest include:

Software engineering.
Web applications.
Developer tools.
Privacy-conscious products.
Practical business software.
Offline-first systems.

The goal is not to build everything.

The goal is to build useful things well.

Building in Public

Wafyro Software is still growing as an independent software initiative.

There will be experiments that work, experiments that fail, architectural decisions that need to be revisited, and products that evolve over time.

I plan to keep improving the products I build and share what I learn through their development and the engineering problems behind them.

Building independently gives me the opportunity to explore ideas, make technical decisions, and learn from the results.

Because software development is not just about writing code.

It's about understanding a problem deeply enough to build something that people can actually use.

That's the direction I'm taking with Wafyro Software.

Build practical. Build thoughtfully. Keep improving.

Building Hishab Ledger: Designing an Offline-First Personal Ledger with Kotlin and Jetpack Compose

Afee Muhammod Wafy — Sun, 27 Sep 2026 11:44:01 +0000

Building Hishab Ledger: An Offline-First Personal Ledger with Kotlin and Jetpack Compose

A software project does not always begin with a technical problem.

Sometimes, it starts with a very ordinary situation.

For me, it started with a disagreement over a grocery shop's baki.

The shopkeeper told me that I had a certain amount outstanding. I remembered the amount differently. The shopkeeper had a handwritten ledger, while I was relying mostly on memory and previous transactions.

The problem was not necessarily the accuracy of either side.

The bigger problem was visibility.

The person maintaining the ledger had a record. The customer did not have an equally convenient way to maintain their own record.

That small observation became the starting point for Hishab Ledger.

What Is Hishab Ledger?

Hishab Ledger is an Android application designed for tracking personal dues, payments, and balances.

The product is intentionally focused on one simple use case:

Keep a clear record of how much you owe, what you have already paid, and what your current balance is across different shops.

Users can add multiple shops as separate records. Each shop can have an opening balance, followed by individual due and payment transactions.

The core balance calculation is:

Current Balance
= Opening Balance
+ Total Due
- Total Payments

Each transaction can also contain:

Amount
Transaction type
Optional note
Exact date and time

The goal was not to build another full accounting system.

It was to build a small, focused tool for an everyday problem: helping customers maintain their own record of baki instead of depending entirely on memory, notebooks, or someone else's ledger.

Why Offline-First?

One of the earliest decisions I made was that Hishab Ledger should work without an account, backend, or internet connection.

For this particular product, the core operation does not require a server.

A user should be able to open the application, check a balance, record a payment, or add a due even when there is no network connection.

That led to an offline-first, local-only architecture.

The application does not depend on a remote database for its primary functionality.

This also gives the product a clear privacy model: the user's ledger data remains on the device unless the user explicitly chooses to export or back it up.

Why JSON Instead of Room or SQLite?

This was one of the more deliberate technical decisions in the project.

For a larger Android application, a database abstraction such as Room can be an excellent choice.

For Hishab Ledger, however, I wanted to keep the storage layer small and straightforward.

The application uses an app-private JSON file for its local data.

The main data structures are essentially:

Shop
├── id
├── name
├── phone
├── address
└── createdAt

Transaction
├── id
├── shopId
├── amount
├── type
├── note
└── timestamp

Transaction types include:

DUE
PAYMENT
OPENING_BALANCE

The application can reconstruct the current balance from these records rather than maintaining a separate balance value that could become inconsistent with the transaction history.

This approach also made full backup and restoration simpler.

The decision was not that JSON is universally better than a database. It was a deliberate choice for the scope and requirements of this particular application.

Building the UI with Jetpack Compose

The Android UI was built using:

Kotlin
Jetpack Compose
Material 3
Material Icons
Android's modern document APIs

The interface follows a relatively simple navigation model.

Home

The home screen provides:

Total due
Total number of shops
Shop search
Shop list
Add Shop action
Settings access

Shop Details

Each shop has its own details screen containing:

Current balance
Add Due
Add Payment
View Summary
Transaction history

Transactions are displayed with their date and time, making the history useful as an actual record rather than just a running number.

Daily Summary

The summary view provides:

Added Due
Payments
Net Change
Current Due

This keeps the application useful not only for checking a total balance, but also for understanding recent activity.

Backup and Restore

Local storage introduces an important responsibility:

Users need a way to move or recover their data.

Hishab Ledger therefore includes JSON backup and restore functionality.

The exported backup contains the application's structured data rather than simply exporting a visual report.

The restore process supports two approaches:

Replace existing data
Merge backup data with existing data

This was particularly important because a local-only application should not make the user feel locked into a single device.

There is also CSV export for users who want their transaction data in a more universally accessible format.

For individual records, Hishab Ledger also supports shop-wise statement export in PDF format.

Keeping the Interaction Model Simple

A major part of the product design was deciding what not to include.

Hishab Ledger is not intended to replace full accounting software.

There is no complex chart of accounts, inventory management system, payroll module, or business analytics dashboard.

The interaction model is intentionally narrow:

Add a shop
    ↓
Set an opening balance
    ↓
Record dues
    ↓
Record payments
    ↓
Check the current balance

That simplicity is part of the product rather than a limitation I wanted to hide.

For a personal ledger, the user should not have to understand an accounting system before recording a payment.

Data Ownership and Privacy

Another product requirement was keeping the user's records under their control.

Hishab Ledger does not require:

An account
A cloud backend
An internet connection for normal use

The application stores its working data locally.

Backup and export are user-controlled operations.

The project also has a dedicated privacy policy explaining how the application handles local data and user-initiated exports.

This approach fits the nature of the application: a personal record should remain useful without requiring a permanent online service behind it.

Product Website and Distribution

The project eventually expanded beyond the Android application itself.

I built a dedicated product website for Hishab Ledger with:

Product information
Feature documentation
Screenshots
How-it-works documentation
Download section
Privacy policy
About page
Changelog
Contact page
SEO metadata
Sitemap
Robots configuration
Responsive layouts

The website is available at:

https://hishabledger.amwafy.xyz

The Android application is also publicly distributed through APKPure:

https://apkpure.com/p/com.afeemuhammodwafy.hishabledger

The Android application and its website were treated as one product rather than two unrelated deliverables.

What I Learned from the Project

Hishab Ledger was useful to me because it covered much more than UI development.

The project involved several different layers:

Problem Discovery
        ↓
Product Definition
        ↓
UX Design
        ↓
Android Development
        ↓
Local Data Architecture
        ↓
Backup & Restore
        ↓
Data Export
        ↓
PDF Generation
        ↓
Product Website
        ↓
Deployment & Distribution

One of the most important lessons was that scope is a technical decision.

It would have been easy to add accounts, cloud synchronization, a backend, notifications, analytics, and more.

Instead, I kept asking:

Does this solve the problem Hishab Ledger was created to solve?

If the answer was no, it did not automatically belong in the product.

That helped keep the application lightweight and focused.

The Bigger Idea Behind Hishab Ledger

The interesting part of this project is not simply that it records numbers.

It is the perspective from which the problem was approached.

Digital ledger software often focuses on the person or business maintaining customer accounts.

Hishab Ledger started from the other side of that relationship:

What if the customer wants to maintain their own record?

That small shift in perspective was enough to turn an everyday problem into a complete product.

And that is probably my favorite part of building software:

A simple real-world observation can eventually become a technical system with its own architecture, interface, documentation, and distribution strategy.

Final Thoughts

Hishab Ledger is a relatively small application, but it gave me the opportunity to work across the entire product lifecycle.

From identifying the problem to designing the interaction model, implementing the Android application, choosing a local data architecture, building backup and export workflows, creating the product website, and preparing the project for distribution.

The project reinforced something I keep finding in software development:

Good products do not necessarily need more features. They need the right features for the problem they are solving.

Hishab Ledger started with a simple question:

How can someone keep track of their own baki without depending on a notebook, memory, or someone else's ledger?

The answer became Hishab Ledger.

About the Creator

Hishab Ledger was created by Afee Muhammod Wafy, an independent developer focused on building practical software products and turning everyday problems into simple digital solutions.

Creator: Afee Muhammod Wafy

Hishab Ledger

Offline Hisab & Due Ledger

A focused, offline-first Android application for keeping personal dues, payments, and balances organized across different shops.

Product Website: https://hishabledger.amwafy.xyz

Download on APKPure: https://apkpure.com/p/com.afeemuhammodwafy.hishabledger

About Me: Afee Muhammod Wafy

Afee Muhammod Wafy — Sat, 12 Sep 2026 14:39:20 +0000

Hello, I'm Wafy — Software Developer | Founder of Wafyro Software

I'm Afee Muhammod Wafy, known as Wafy — a self-taught software developer and science student from Bangladesh, and the founder of Wafyro Software.

I build web applications, developer utilities, and security-focused tools while exploring the underlying principles of software development, web technologies, and cybersecurity.

I believe in learning by building, understanding systems from first principles, and turning ideas into practical software.

Quick Facts

Name: Afee Muhammod Wafy
Professional Title: Software Developer
Founder: Wafyro Software
Location: Bangladesh
Education: Higher Secondary Certificate (HSC), Science
Primary Focus: Web Development, Full-Stack Development, and Software Projects
Interests: Software Engineering, Cybersecurity, Python, JavaScript, and Artificial Intelligence

About Me

My interest in technology comes from a desire to understand how things work beneath the surface.

As a science student, I enjoy breaking down complex problems, identifying their underlying logic, and exploring how different components interact. Programming gives me a practical way to apply this approach.

Rather than limiting myself to tutorials, I focus on building independent projects and learning through implementation, experimentation, debugging, and continuous improvement.

My development journey has introduced me to frontend and backend development, APIs, databases, web security, and browser-native technologies.

Through Wafyro Software, I aim to build useful software products while continuing to grow as a developer.

What I Do

My primary focus is building practical software, particularly web applications and developer-focused tools.

Technologies I work with:

Languages: JavaScript, Python, C
Frontend: HTML, CSS, Vanilla JavaScript, Responsive UI Development
Backend: Python, Flask, REST APIs
Databases: PostgreSQL, SQLAlchemy, SQL
Tools & Platforms: Git, GitHub, Linux
Other Areas: API Integration, Web Security, UI/UX, Browser APIs, and Privacy-Conscious Data Handling

I value clean implementation, maintainability, security, and choosing technologies based on the actual needs of a project.

Featured Projects

WafyShield — Website Security Audit Scanner

WafyShield is a web security auditing tool that checks common website security configurations and presents actionable findings.

Key features:

HTTPS and TLS configuration checks
Security header analysis
Cookie security attribute checks
PASS, WARNING, and FAIL results
Security scoring and remediation recommendations

Building WafyShield has helped me explore security headers, redirects, SSRF protection, request isolation, and privacy-conscious application design.

WafyURL — URL Shortening & Link Management

WafyURL is a full-stack URL shortening and link management application built with Python, Flask, PostgreSQL, and SQLAlchemy.

Key features:

Custom URL aliases
Password-protected links
QR code generation
Click analytics
Bulk URL processing

This project has given me practical experience with backend architecture, database indexing, connection pooling, HTTP redirects, authentication flows, and privacy-conscious analytics.

WafyDev — Browser-Based Developer Utilities

WafyDev is a privacy-focused collection of developer and productivity tools built with HTML, CSS, and Vanilla JavaScript.

Key features:

Password Generator
QR Code Generator
Typing Test
Study Timer
Markdown Preview
Note Taker
Countdown Timer
Text Utilities
Color Palette

The project explores browser-native APIs, local storage, client-side processing, Markdown sanitization, cryptographically secure random number generation, and timer accuracy.

AstroWafy — Educational Astronomy Platform

AstroWafy is an educational astronomy project that integrates NASA's public APIs to make astronomy-related content more accessible.

Key features:

NASA Astronomy Picture of the Day (APOD) integration
English and Bengali content
Date-based navigation
High-resolution image handling
Download functionality
Local caching and client-side sanitization

This project has helped me explore asynchronous JavaScript, API integration, AbortController, Blob handling, caching, and bilingual interface design.

My Development Philosophy

I believe the best way to learn programming is to build, test, and improve real projects.

My approach focuses on:

Understanding the fundamentals: Learning why a solution works, not just how to implement it.
Practical problem-solving: Applying concepts to real development challenges.
Simplicity: Avoiding unnecessary complexity and dependencies.
Security and privacy: Considering potential risks throughout development.
Continuous improvement: Learning from bugs, documentation, experimentation, and feedback.

I see software development as more than writing code. It involves understanding problems, making informed technical decisions, handling edge cases, and building solutions that are useful and maintainable.

Security & Privacy

Cybersecurity is an important area of interest in my development journey.

Through projects such as WafyShield and WafyURL, I have explored website security configurations, authentication, password protection, secure random number generation, request handling, and privacy-conscious telemetry.

These experiences have strengthened my understanding that security and privacy should be considered throughout the development process, not added as an afterthought.

Certifications & Learning

Alongside my academic studies and practical projects, I have completed courses and certifications in technology-related fields.

Digital Skills: Artificial Intelligence — FutureLearn & Accenture, 2026
Intro to Cyber Security — FutureLearn & The Open University, 2026
Basics of Python — UniAthena, 2026

These learning experiences complement my hands-on work in software development, Python, artificial intelligence, and cybersecurity.

Education

Gangachara Govt. College, Bangladesh

Higher Secondary Certificate (HSC), Science

Gangachara Govt. Model High School, Bangladesh

Secondary School Certificate (SSC), Science

My academic background in science supports my analytical approach to problem-solving, while software development allows me to apply that mindset to practical technical challenges.

Beyond the Code

I'm still learning, experimenting, and expanding my understanding of software development.

I enjoy exploring unfamiliar concepts, reading documentation, investigating bugs, and understanding the mechanisms behind the technologies I use.

My long-term goal is to strengthen my software development and engineering skills, contribute to meaningful projects, and continue growing as a software professional.

For me, progress comes from curiosity, consistent practice, and a willingness to understand things deeply.

Let's Connect

Portfolio: https://afeemuhammodwafy.com/
GitHub: https://github.com/afeemuhammodwafy1
LinkedIn: https://bd.linkedin.com/in/afeemuhammodwafy1

I'm always interested in learning, building useful software, and connecting with people who share an interest in technology.

Build a Lightweight Web Security Scanner with Next.js: Meet WafyShield 🛡️

Afee Muhammod Wafy — Wed, 09 Sep 2026 15:00:38 +0000

Web security shouldn't be complicated, yet most enterprise-grade security auditing tools lock basic checks—such as SSL validation, security header analysis, and cookie security—behind confusing interfaces or expensive paid subscriptions.

In order to address this, I created WafyShield, a lightweight, fast, and serverless web security scanner designed to evaluate any public website in seconds with a strong focus on privacy and zero server-side storage.

🌐 Live Application & Source

Live Application: shield.amwafy.xyz
GitHub Repository: github.com/afeemuhammodwafy1/wafyshield

⚡ Key Features

HTTPS & SSL Security Check: Confirms whether a website properly enforces secure transport and inspects TLS certificate details (such as issuer, subject, and expiration dates).
Security Headers Checker: Audits OWASP-recommended headers like HSTS, Content-Security-Policy (CSP), X-Frame-Options, X-Content-Type-Options, Referrer-Policy, and Permissions-Policy.
Cookie Security Audit: Detects cookies set by the server and verifies essential flags like Secure, HttpOnly, and SameSite.
Instant Security Score & Risk Level: Calculates a clear 0–100 score alongside an overall risk tier (Low, Medium, High, or Critical).
Remediation Guides: Provides copy-pasteable fix recommendations for every warning or failed check.
Client-Side History & JSON Export: Stores recent scan reports locally in the browser (localStorage) and allows exporting full reports as JSON.
Responsive UI & Dark Mode: A clean, green-themed interface built with a built-in dark/light mode toggle.

🛠️ Architecture & Tech Stack

Framework: Next.js 14 (Pages Router) for fast routing and serverless efficiency.
Styling: Scoped CSS-in-JS (styled-jsx) for clean component-level design without heavy UI libraries.
Backend & Compute: Next.js Serverless API Routes utilizing Node.js native fetch and tls modules.
Hosting: Vercel Serverless Functions to ensure minimal latency and zero maintenance overhead.

💡 Engineering Highlights

1. Guarding Against SSRF (Server-Side Request Forgery)

Since the server performs fetch requests on behalf of users, malicious inputs could potentially target internal or private network ranges (like localhost or 127.0.0.1). To prevent this abuse, the URL normalizer strictly blocks private and local IP addresses before making any outbound network calls.

2. Direct TLS Socket Inspection

Instead of relying on heavy third-party packages to inspect SSL certificates, WafyShield connects directly to port 443 using Node.js's built-in tls module to extract certificate metadata securely and efficiently.

3. Lightweight In-Memory Caching

To minimize redundant external requests and speed up response times for repeated lookups, an in-memory cache with a Time-To-Live (TTL) mechanism was implemented directly inside the serverless execution environment.

👨‍💻 About the Author

Built by Afee Muhammod Wafy.

For more projects, visit https://afeemuhammodwafy.com or connect on GitHub.

Building WafyURL: A High-Performance URL Shortener with Real-Time Analytics & Security

Afee Muhammod Wafy — Mon, 24 Aug 2026 09:14:37 +0000

Link management shouldn't be complicated since most URL shorteners put essential features—such as custom slugs, password protection, and analytics—behind costly monthly paywalls.

In order to deal with this, I created WafyURL, a fast, secure and fully featured link management platform which is designed with a focus on speed and privacy.

🌐 Live Application & Source

Live Application: url.amwafy.xyz
GitHub Repository: github.com/afeemuhammodwafy1/wafyurl

⚡ Key Features

Custom Slugs: Create branded and easy-to-remember links in order to enhance click-through rates.
Detailed Analytics: Monitor the total number of clicks, geographic location, device types, operating systems, and referrers without using heavy third-party trackers.
Password Protection: Include an optional password to secure sensitive destinations using SHA-256 encryption.
Auto-Expiration: Set links to expire by themselves after 1 hour, 24 hours, 7 days, or 30 days.
Bulk Shortening: Generate multiple shortened URLs at the same time with just one click.
QR Code Generation: Instantly generate downloadable QR codes on the client side for use in printing and marketing campaigns.
Destination Preview: Extract Open Graph metadata on the server side to preview destination links before redirection.

🛠️ Architecture & Tech Stack

Backend: Python 3.11 together with Flask, which offers a lightweight and modular routing base.
Database: PostgreSQL running on Neon Serverless, managed via Flask-SQLAlchemy.
Hosting & Compute: Vercel Edge Serverless Functions to achieve minimal global latency.
Frontend: Semantic HTML5, Vanilla JavaScript, and modern CSS3 Glassmorphism without employing heavy frameworks.

💡 Engineering Highlights

1. Optimising the Database for a Serverless Environment

Since serverless backends tend to open and close connections rapidly, this can cause standard database pools to become exhausted. To make sure response times remain stable during traffic surges, persistent connection pooling, connection recycling, and automated pre-pings were configured.

2. Zero-Dependency Client Execution

Key frontend features—such as dynamic QR code rendering and the collapsible FAQ accordion—are handled natively instead of relying on large third-party JavaScript libraries. This ensures minimal bundle sizes and faster Time-to-Interactive (TTI).

3. Integrated Security & Abuse Prevention

To ensure platform stability, a sliding-window rate limiter based on IP addresses prevents spam and brute-force requests. Furthermore, password-protected endpoints verify SHA-256 hashes prior to executing any redirect logic.

👨‍💻 About the Author

Built by Afee Muhammod Wafy.

For more projects, visit https://afeemuhammodwafy.com/ or connect on GitHub.

Why I Built WafyDev: A Zero-Dependency, 100% Client-Side Developer Suite

Afee Muhammod Wafy — Sun, 23 Aug 2026 17:10:11 +0000

Every developer knows the struggle of having twenty different browser tabs open just for small daily tasks: generating a quick QR code, formatting a snippet of text, testing typing speed, or checking Markdown rendering. Most existing online tools are bloated with intrusive ads, take ages to load, or send unnecessary requests to external servers.

To solve this, I built WafyDev—a clean, fast, and completely free developer toolbox packed with 9 essential utilities.

Why I Built WafyDev

The core idea was simple: build a lightweight workspace where daily developer and productivity utilities live under one roof without unnecessary friction.

Instead of relying on heavy frontend frameworks, I designed WafyDev with pure HTML5, CSS3, and JavaScript. This ensures instant page loads, zero framework bloat, and minimal resource usage on any device.

Key Features & Core Philosophy

100% Client-Side & Private: Everything runs directly inside your browser. Sensitive actions—like generating passwords or saving local notes—never leave your machine.
Ad-Free & Distraction-Free: A modern, dark-themed interface built for focus and speed.
Zero Latency: Tools respond instantly with no server roundtrips required for processing.
Responsive Workspace: Optimized for seamless usage across mobile, tablet, and desktop screens.

The 9 Built-in Utilities

🔐 Password Generator: Create strong, cryptographically secure passwords with a real-time strength meter.
📱 QR Code Generator: Instantly generate and export custom QR codes for links and text.
⌨️ Typing Speed Test: Measure real-time words per minute (WPM), accuracy, and error rates.
⏱️ Study Timer: A Pomodoro-style productivity timer with customizable focus and break sessions.
📝 Markdown Preview: Live real-time Markdown editor with instant HTML rendering and raw toggle.
📒 Note Taker: A lightweight in-browser scratchpad with instant local storage and search.
⏳ Countdown Timer: Track days, hours, and minutes remaining for events and deadlines.
🔤 Text Utilities: Fast case conversion, whitespace cleanup, and real-time word/line/character counting.
🎨 Color Palette: Pick and inspect colors with instant HEX, RGB, and HSL values.

What's Next?

WafyDev is an open-source project licensed under MIT. I am continuously working on adding more tools like JSON formatters, Base64 encoders, and offline PWA support.

If you are looking for a straightforward, distraction-free utility suite for your daily workflow, check it out:

Live Demo: https://dev.amwafy.xyz
GitHub Repository: github.com/afeemuhammodwafy1/wafydev

Feel free to explore the project, star the repo on GitHub, or suggest new features you would love to see added!