DEV Community: Iqra Khan

Unburden: What If AI Helped You Carry Less?

Iqra Khan — Fri, 23 Oct 2026 13:39:08 +0000

I Built an AI That Tells You to Do Less (And Means It)

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

"What if the most helpful productivity tool didn't ask you to do more? What if it helped you carry less?"

We've all had days when our to-do list feels less like a plan and more like a browser with 47 tabs open. Reply to that message. Finish that assignment. Buy groceries. Start the project. Remember the other thing you forgot to write down.

The problem isn't always a lack of discipline. Sometimes, the hardest part is simply deciding where to begin.

That's why I built "Unburden — Do Less, Move Gently".

Unburden is a gentle, AI-powered task planner built around one idea: "reduce the weight of starting, not increase the pressure to finish."

Here's how it works:

"Empty your head." Dump your unfinished tasks, reminders, and mental clutter into one box. No perfect formatting required.
"Choose your energy level." Tell Unburden whether you're running on barely anything, have some energy, or feel ready to go.
"Let the model shrink the starting line." It turns your messy task dump into a small first action and optional next steps.
"Stop when you've done enough." Check off tasks, copy your plan, or simply take the first step. The app doesn't turn your day into a 47-step routine.

For example, “Finish my DBMS notes, reply to my professor, clean my desk, and start my project report” shouldn't have to become another overwhelming checklist.

The goal is to make the first action feel small enough to begin.

Unburden is for students, overwhelmed beginners, busy people, and anyone who has ever confused being productive with being constantly busy.

I wanted to build something that treats energy as a real constraint, not a character flaw.

Demo

Try Unburden here: (https://iqrakhan2909.github.io/Unburden/)

A quick way to explore it:

Click 'Use a sample brain dump'.
Select an energy level.
Click 'Make this feel lighter'.
Explore the suggested first step and optional tasks.

The first model load requires an internet connection. After that, browser caching may help, but fully offline operation is not guaranteed.

Code

The complete project is open for inspection on GitHub:

"(https://github.com/iqrakhan2909/Unburden)"

The app is built with three core files:

index.html — the structure and interface.
style.css — the responsive visual design.
script.js — model loading, inference, task-plan parsing, interaction, and fallback handling.

I deliberately kept the implementation small and browser-based. There is no custom backend or hosted AI inference API in the app.

How I Built It

I built Unburden using HTML, CSS, JavaScript, Transformers.js, and the open-weight Xenova/flan-t5-small model.

The technical decision that matters most is where the inference happens.

Instead of sending the user's task dump to a hosted AI chat API, the browser loads the model through Transformers.js and runs inference in the browser. The app doesn't require an AI API key or a custom inference server.

The model receives a prompt that asks it to produce five short lines: one very small first action followed by optional next actions. The prompt also changes according to the user's selected energy level.

The generated text is parsed into a simple plan, then rendered as an interactive list with checkboxes and a copy option.

I also added a fallback path. If model loading or generation fails, Unburden can offer a basic rule-based plan, clearly labelled as a fallback rather than pretending it came from the AI model.

That distinction matters: a fallback can keep the interface useful, but it is not a substitute for successful model inference.

The design was intentional, too. Soft colours, generous spacing, a little sloth-inspired personality, and language without productivity guilt all support the same goal: make starting feel lighter.

The result is a small, self-contained experiment in building AI that respects a person's capacity instead of demanding more of it.

Why Does Open Innovation Matter?

For me, open innovation is about more than making source code publicly visible. It's about giving builders and users more control over the technology they depend on.

Unburden is a small example of what that control can look like.

The model is not a black box behind a paid API.

Using an open-weight model means the model's weights are available to work with under its applicable licence. Developers can inspect the implementation around it, experiment with different compatible models, and adapt the experience without being locked into one hosted AI provider.

The user's task dump doesn't need to travel to a hosted AI inference service.

Unburden runs model inference in the browser. Its task-planning flow doesn't send the brain dump to a hosted AI chat API. That reduces one important source of data exposure and makes the privacy design easier to explain.

This isn't a claim that all browser activity is private or that the app is suitable for highly sensitive information. The model and application code still have to be downloaded, and the first model download requires internet access.

Experimentation becomes more accessible.

A beginner can build and publish an AI-powered application without setting up an inference server or managing a paid AI API key. A static website can host the interface while the browser handles inference.

That lowers the barrier to experimenting with AI. It also makes the project easier for other developers to study, fork, and improve.

Open technology lets us question the default design.

Many productivity products are built around doing more, faster. By making the model and surrounding implementation accessible, builders can experiment with different prompts, interaction patterns, and values.

In Unburden, that means asking a different question: not “How can AI help someone finish everything?” but “How can AI help someone find one manageable place to begin?”

Open innovation doesn't automatically make a model accurate, private, or free of limitations. It gives us more room to inspect, test, and improve the choices we make.

And that room to experiment is exactly what made this project possible.

The Lazy Payoff

The payoff isn't a claim that Unburden saves a guaranteed number of minutes. I haven't conducted a timed user study, and I don't want to invent a productivity statistic just to make the project sound impressive.

The intended saving is the effort spent deciding where to begin.

Instead of manually sorting a messy brain dump, the user gets a suggested first action and optional next steps. Choosing an energy level helps shape those suggestions, while the fallback means a basic plan may still be available if the model cannot load.

The bigger idea is that 'you don't have to turn every unfinished task into an emergency, and you don't have to finish everything to make progress'.

Sometimes, the most useful output from AI isn't another enormous plan.

It's one small next step — and permission to stop there.

A Final Thought

I built Unburden for the days when the list is long, the energy is low, and even deciding what to do feels like work.

The sloth has a lesson for us: moving slowly isn't the same as standing still.

If AI can help us remove a little friction without adding more pressure, that's a kind of productivity worth building for.

"Less overwhelm. One next move. Slow is still a speed."

devchallenge #hf26challenge #hacktoberfest #opensource #ai #javascript #transformersjs

From “Hey, I Need an Order” to Done: Meet OrderSaathi

Iqra Khan — Wed, 14 Oct 2026 15:27:48 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

OrderSaathi: A Little AI Assistant for Small Businesses

What I Built

Running a small business means doing a lot of little things yourself: answering customer messages, figuring out exactly what someone wants to order, checking whether important details are missing, and writing replies while trying to manage everything else.

"OrderSaathi is my attempt to make that daily work a little easier."

It is a browser-based AI assistant designed for small shop owners, home bakers, Instagram sellers, resellers, and other small businesses that receive customer orders through chat messages.

Imagine a customer sends:

Hi, I need 2 chocolate cakes for tomorrow. One should be half kg and the other 1 kg. Please deliver in the evening.

Instead of reading the message several times and manually organising the details, the seller can paste it into OrderSaathi. The app uses AI to help turn the message into a more structured order summary, identify potentially missing information, and draft a reply for the customer.

The goal is simple: less time organising messages, fewer overlooked details, and smoother customer communication.

Who could pay for it?

OrderSaathi is designed for people who may not have the budget for a dedicated order-management system, especially:

Home bakers and home-based food businesses.
Instagram and WhatsApp sellers.
Small retailers managing orders through messages.
Freelancers and solo entrepreneurs who handle customer requests themselves.

A possible future business model would be a free basic version with an affordable monthly plan for features such as saved order history, reusable reply templates, and support for multiple business workflows. This is a potential monetisation plan, not an existing paid service.

Demo

Try OrderSaathi here:

iqrakhan2909.github.io

The project is deployed on GitHub Pages. The browser-based AI model may need an internet connection to download the model the first time it runs.

Code

The complete source code is available on GitHub:

iqrakhan2909 / OrderSathi_project

OrderSaathi — Small Business, Smarter Orders 🌿

Turn messy customer messages into business-ready order briefs using open-weight AI in your browser.

OrderSaathi is a privacy-conscious AI assistant designed for home bakers, tiffin-service providers, handmade-product sellers, freelancers, and other small business owners who receive customer orders through informal messages.

Instead of manually interpreting every message, sellers can paste a customer's request and generate a structured order brief, identify missing details, and draft a professional reply.

Built for the Side Hustle: Open-Source AI Challenge.

✨ The Problem

Small business owners often receive orders in informal English, Indian English, Hinglish, abbreviations, and incomplete messages.

For example:

Didi 2 chocolate cakes chahiye Sunday ko, one is 1 kg and dusra half kg, naam Aanya likhna hai, budget 1200 ke andar ho toh batao.

A seller needs to understand the quantities, cake sizes, requested name, delivery date, and budget while figuring out what still…

View on GitHub

The project is built using three main application files:

index.html — the application structure.
style.css — the user interface and styling.
script.js — the application logic and AI-powered message processing.

I kept the project lightweight so that it is easy to explore, understand, modify, and contribute to.

How I Built It

OrderSaathi uses 'Transformers.js and the open-weight Xenova/flan-t5-small model' to bring AI-powered text processing into the browser.

The application is built with HTML, CSS, and JavaScript. Instead of sending every customer message to a paid, hosted AI inference API, it uses browser-based inference through Transformers.js.

The basic workflow is:

The user selects a business category and enters a customer message.
The application passes the text to the AI-powered processing workflow.
The model helps generate a structured summary and a customer reply, including information about details that may need clarification.
The user reviews the result and can copy it or download an order brief.

The project is intentionally small. I wanted to explore how an open-weight model could support a specific, everyday business task without requiring a complicated backend or a paid inference service.

It is important to be clear about the current limitations: the model is small, generated details can be imperfect, and the output should be reviewed before it is used for a real order. The current version is a prototype, not a replacement for a complete order-management system.

Why Does Open Innovation Matter?

For a small business, the cost of an AI feature matters just as much as the feature itself.

A conventional approach would be to connect the application to a closed, hosted AI API. That can be useful, but it also introduces an external service dependency, usage-based costs, API-key management, and a new place where customer messages may be processed.

For OrderSaathi, I wanted to explore a different approach.

No per-message hosted inference bill

Because inference runs in the browser, the app does not need to pay a hosted AI inference provider for every message processed. That makes the idea more practical to experiment with when serving users who may have very limited budgets.

A better starting point for customer privacy

The app's browser-based inference approach means customer message text can be processed locally rather than being sent to a hosted inference API by the application. This is useful for messages that may contain names, addresses, delivery instructions, or other order details.

This does not automatically guarantee complete privacy: the website still loads its application assets and model files, and production use would need careful privacy and security testing.

More freedom to experiment

Using an open-weight model makes it possible to study the model, evaluate alternatives, and experiment with different models or workflows as the project grows, subject to their respective licences and technical requirements.

Lower barriers to building useful AI

A student or independent developer can experiment with AI-powered products without immediately needing a paid inference account, a dedicated GPU server, or a complex backend.

That is what open innovation means to me: making AI easier to experiment with, adapt, and build upon.

A closed API might provide stronger performance or more advanced capabilities in some situations. I am not claiming that a small browser model beats every hosted model. For this project, the advantage is the opportunity to explore a useful, affordable, and potentially privacy-conscious workflow with fewer infrastructure dependencies.

My First User

OrderSaathi is currently a prototype, and I am still looking for its first real-world users.

I do not have a verified paying customer or user-feedback story to share yet. My next step is to put it in front of a few home bakers and small online sellers, observe how they handle real order messages, and use their feedback to improve the workflow.

If you run a small business or know someone who does, I would love to hear whether a tool like this would genuinely save time—and what would make it useful enough to pay for.

Prize Categories

Overall Hacktoberfest Open-Source AI Challenge entry.

I am not claiming a partner prize category at this stage because I have not established that the current project meets a specific partner category's requirements.

What's Next?

I would like to explore:

Better handling of Hinglish and informal customer messages.
More reliable detection of missing order details.
Custom reply templates for different business types.
Optional order history and export features.
Testing with real small-business owners to understand what they actually need.

I built OrderSaathi around a simple question: "Can a small, accessible AI tool take one repetitive task off a small business owner's plate?"
It is an early experiment, but I hope to turn it into something genuinely useful.

If you try it, I would appreciate your feedback. What would you change, and would you use it in your own small business?

devchallenge #hf26challenge

404: Nature Not Found? WildQuest Fixes That.

Iqra Khan — Fri, 09 Oct 2026 19:22:40 +0000

🌿 WildQuest: Touch Grass, For Real — An Open-Source AI Adventure Generator

Less scrolling. More living.

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

What if AI didn't try to keep you on your screen longer, but helped you put your phone away?

That's the idea behind WildQuest — a browser-based outdoor adventure generator that uses open-weight AI to turn your mood, available time, interests, and surroundings into a small, practical outdoor mission.

Instead of endlessly scrolling for something to do, you can generate an activity, step outside, explore your surroundings, and reconnect with the world beyond your screen.

What I Built

WildQuest — Touch Grass, For Real is a lightweight, interactive web application designed to help people take meaningful breaks from screens and discover the outdoors in everyday life.

The idea is simple: going outside shouldn't require an elaborate plan, expensive equipment, or an entire free afternoon. Sometimes, all you need is a little inspiration.

WildQuest lets users personalize an outdoor quest using four choices:

Setting: A nearby park, a garden or balcony, a neighbourhood walk, or a nature trail.
Available time: 5, 15, 30, or 60 minutes.
Energy level: Choose the mood that fits how you feel that day.
Interests: Explore themes such as birds and wildlife, plants and small details, movement, mindfulness, or spending time with a friend.

Based on these preferences, the application uses an open-weight AI model to generate a short outdoor adventure with a title, introduction, mission, and actionable steps.

For example, someone with only 15 minutes to spare might receive a sensory exploration challenge, a tiny wildlife observation mission, or a short neighbourhood discovery activity.

The goal isn't to make people interact with another app for hours. It's to make the decision to go outside easier — and then encourage them to put the phone away.

Key features

Personalized outdoor quests: Activities are generated from the user's selected setting, available time, energy, and interests.
Open-weight AI in the browser: The model performs inference locally in the browser instead of relying on a private AI inference API.
No paid inference API key: The demo does not require a dedicated AI backend or paid inference service.
Fallback activities: If the AI library or model fails to load, users can still receive a ready-made outdoor quest.
Responsive interface: The application is designed for desktop and mobile screens.
Safety-conscious prompts: Generated activities are guided to avoid disturbing wildlife, entering private property, eating unknown plants, or suggesting risky activities.

WildQuest is built around one small but meaningful idea: technology can be useful without demanding more of our attention.

Demo

🌐 Live website: https://iqrakhan2909.github.io/WildQuest-Touch-Grass-Project/

💻 GitHub repository: https://github.com/iqrakhan2909/WildQuest-Touch-Grass-Project

Try choosing different settings, time limits, energy levels, and interests to see how the outdoor quest changes.

The first AI model load requires an internet connection and may take some time. If local model generation is unavailable, the application falls back to a ready-made quest. Fully offline operation on the first visit is not guaranteed.

Code

The complete project is available on GitHub:

👉 Explore the WildQuest source code

The project uses a simple three-file frontend structure:

index.html — The page structure, outdoor quest planner, input controls, and results interface.
style.css — The visual design, responsive layouts, animations, and nature-inspired styling.
script.js — Preference handling, prompt construction, local AI model loading, output processing, fallback quests, and user interactions.

The repository also includes a README explaining setup, features, the AI implementation, safety considerations, and future improvements.

The project is released under the MIT License, making it available for others to explore, adapt, and build upon under the license terms.

How I Built It

I built WildQuest using HTML, CSS, vanilla JavaScript, Transformers.js, and the open-weight FLAN-T5 Small model.

The goal was to create a practical AI-powered experience without depending on a paid hosted language-model API or building an unnecessarily complicated backend.

1. Frontend and user experience

I used HTML to structure the application and collect the user's preferences, CSS to create a responsive, nature-inspired interface, and vanilla JavaScript to manage form submissions, model interactions, and generated quests.

I wanted the experience to be straightforward: choose a few preferences, generate a quest, and head outdoors.

2. Open-weight AI model

The application uses:

Model: Xenova/flan-t5-small
Inference library: Transformers.js
Task: Text-to-text generation
Runtime: The user's browser

Transformers.js loads the model and enables it to generate text in the browser. There is no separate private AI inference server handling the user's activity preferences.

3. Turning preferences into an outdoor mission

When a user submits the form, JavaScript collects their choices and builds a prompt containing the selected setting, duration, mood, and interests.

The prompt instructs the model to produce four sections:

A short, engaging title.
A friendly introduction.
A clear outdoor mission.
Three simple, practical steps.

The instructions also encourage safe, accessible activities that require no special equipment and help the user spend less time looking at a screen.

The generated response is parsed and displayed in the interface.

4. Making the experience resilient

A model can fail to load, take too long to initialize, or return output that doesn't match the expected format. I didn't want those situations to make the entire application unusable.

WildQuest therefore includes a collection of ready-made quests. If local generation fails or the model output cannot be parsed, the application can display a fallback activity instead.

This means the core experience remains available even when the AI component isn't working.

5. Deployment

The frontend is deployed through GitHub Pages, making the application accessible through a public website without requiring a dedicated application server.

The initial page, Transformers.js library, and model download require internet access. Although browser caching may allow some resources to be reused later, WildQuest does not claim guaranteed offline operation.

Why Does Open Innovation Matter?

For WildQuest, open innovation isn't just about using a different model. It changes how the application can be built, inspected, adapted, and used.

1. More control over the technology

Using an open-weight model gives developers the opportunity to experiment with prompts, adjust application behavior, and explore compatible models rather than depending entirely on a closed provider's API and product decisions.

WildQuest can be extended with different types of outdoor activities, community-specific suggestions, or alternative models as the project evolves.

2. A more privacy-conscious architecture

People should be able to choose a simple outdoor activity without needing to send their preferences to a private AI inference service.

WildQuest processes the selected preferences and runs model inference in the browser. This reduces the need to transmit those preferences to a separate AI inference provider.

This does not mean that every part of the website is offline or that the initial model download requires no network connection. It means that the AI inference itself is designed to happen on the user's device.

3. Lower barriers to experimentation

A small project shouldn't necessarily need a paid API key, a backend server, and ongoing inference costs just to demonstrate an idea.

By using browser-based inference and open-weight AI, WildQuest offers a way to experiment with AI-powered personalization without a dedicated paid inference service.

The model download and the user's device capabilities still matter, but the architecture keeps the project relatively accessible to learners and independent developers.

4. The community can build on it

Open-source projects create opportunities for others to inspect the implementation, report problems, improve prompts, suggest safer activities, and contribute new features.

Someone could extend WildQuest with local weather information, a nature journal, bird and plant observation tools, or more reliable installable offline support.

These are potential future improvements, not features currently claimed by the demo.

5. AI should serve people, not just screen time

Perhaps the most important reason open innovation matters here is the purpose behind the technology.

AI is often experienced through products designed to maximize engagement. WildQuest explores a different direction: use AI to reduce the effort needed to make a decision, then encourage the user to leave the interface and experience the real world.

The best outcome isn't a longer session on WildQuest. It's someone closing the tab and discovering something outside.

My Agent Session

I haven't included a DevRelay agent session in this submission.

The project source code is available in the GitHub repository linked above. If I record and publish a DevRelay session, I'll add its link here.

Prize Categories

Hacktoberfest Open-Source AI Challenge Week 1 — Touch Grass: Overall challenge submission.

I'm not claiming eligibility for any specific partner prize category because the current project is built with Transformers.js and FLAN-T5 Small rather than the listed partner technologies.

What's Next?

WildQuest is a starting point, and there are several directions I'd like to explore:

Weather-aware quests based on local conditions.
A nature journal to record discoveries after returning indoors.
Bird and plant observation activities.
Better model-loading feedback and more consistent AI output.
Optional installable PWA support with tested offline capabilities.
More opportunities for community contributions.

These improvements could make WildQuest more useful while keeping its central purpose intact: helping people spend less time on screens and more time noticing the world around them.

Final Thoughts

Building WildQuest made me think about a different way to approach useful AI.

Instead of asking how to make people spend more time with a product, I wanted to explore how technology could help them do something meaningful beyond it.

An outdoor adventure doesn't have to be a mountain hike or an entire weekend away. It could be noticing a bird outside your home, taking a different route through your neighbourhood, or spending five quiet minutes observing the plants around you.

Sometimes, a small nudge is enough to get started.

🌱 Less scrolling. More living. Touch grass, for real.

hacktoberfest #hf26challenge #devchallenge #opensource #ai #webdev