Forem: PRADEEP HEBBALLI

OpenOdds Casino

PRADEEP HEBBALLI — Tue, 19 May 2026 13:19:57 +0000

OpenOdds Casino: A Transparent Casino-Style Simulator Where the Odds Are Visible

I built OpenOdds Casino for the MeDo Hackathon.

Most casino-style apps are built around suspense, colors, music, and excitement. But one important thing is usually hidden from the user:

the real odds.

OpenOdds Casino was built around a different idea:

What if a casino-style game showed the win probability, loss probability, payout, house edge, and audit trail before every play?

That is the core concept behind OpenOdds Casino.

What Is OpenOdds Casino?

OpenOdds Casino is a virtual-credit-only casino-style simulator built with MeDo.

It is not a real-money gambling platform.

There are:

No deposits
No withdrawals
No wallet
No crypto
No redeemable prizes
No real-money rewards

Every user starts with 1,000 virtual demo credits, and all games are played only inside the simulation.

The goal is to demonstrate how casino-style digital experiences can be made more transparent, auditable, and responsible.

The Main Idea

Most games focus on the experience first and the math second.

OpenOdds Casino puts the math directly in front of the user.

Before playing any game, the user can see:

Win probability
Loss probability
Payout multiplier
Expected return
House edge
Risk level
Game explanation
Audit logic

The maximum win probability for any game is capped at 20%, and this is clearly displayed.

The app does not hide the odds. It makes the odds part of the experience.

Games Included

Game	Win Probability	Loss Probability	Payout	House Edge
Neon Slots	12%	88%	5x	40%
Lucky Wheel	15%	85%	4x	40%
Dice Duel	18%	82%	3x	46%
Card Flip	20%	80%	2.5x	50%
Crash Line	10%	90%	6x	40%
Treasure Vault	8%	92%	8x	36%
Roulette Lite	16%	84%	4x	36%
Coin Storm	14%	86%	5x	30%

Each game is intentionally transparent about the fact that the odds are unfavorable to the player.

How the Math Works

The app uses a simple transparent probability model.

For each game round:

randomValue = random number between 0 and 1

if randomValue <= gameWinProbability:
    result = win
else:
    result = loss

The expected return is calculated as:

$$
Expected\ Return = Win\ Probability \times Payout\ Multiplier
$$

The house edge is calculated as:

$$
House\ Edge = (1 - Expected\ Return) \times 100
$$

For example, Neon Slots has a win probability of 12% and a payout of 5x.

$$
Expected\ Return = 0.12 \times 5 = 0.60
$$

$$
House\ Edge = (1 - 0.60) \times 100 = 40\%
$$

This means the game is mathematically unfavorable, but the user sees that clearly before playing.

That is the point of OpenOdds Casino.

Transparent Logic Example

{
  "game": "Neon Slots",
  "winProbability": 0.12,
  "lossProbability": 0.88,
  "payoutMultiplier": 5,
  "expectedReturn": 0.60,
  "houseEdge": "40%",
  "logic": "If randomValue <= 0.12, user wins. Otherwise, user loses."
}

Transparency Engine

The Transparency Engine is the core trust layer of the app.

It shows:

All game probabilities
Loss probabilities
Payout multipliers
Expected return
House edge
Risk level
Probability formula

Instead of hiding the odds behind the visual experience, the app makes the odds part of the experience.

Open Analysis Page

The Open Analysis page explains how the simulator works.

It includes:

JSON-style game configuration
Probability settings
Payout multipliers
House-edge values
Pseudo-code for outcome generation
Audit-log schema
Local-storage schema
Virtual credit logic

This page was added because transparency should not only be visual. It should also be structural.

Audit Log

Every play is recorded locally in an audit log.

Each audit entry includes:

Timestamp
Game name
Bet amount
Win probability
Loss probability
Result
Credits before play
Credits after play
Payout amount
Play ID
Probability rule used

The user can also export the audit log as a CSV file.

This makes the app more trustworthy because every round is traceable.

Responsible Play Features

OpenOdds Casino includes responsible-play safeguards because casino-style interaction can become harmful if it is designed irresponsibly.

The app includes:

[x] Virtual credits only
[x] Clear no-real-money disclaimer
[x] No deposits or withdrawals
[x] No redeemable rewards
[x] No fake jackpot language
[x] No near-miss manipulation
[x] No countdown pressure
[x] No urgency mechanics
[x] Break reminders
[x] Loss warnings
[x] Reduced Stimulation Mode
[x] Optional audio controls

Responsible Play is not hidden in fine print. It is a dedicated part of the app.

Audio and Reduced Stimulation Mode

The app includes casino-style music and sound effects, but audio is controlled carefully.

Audio is:

Muted by default
Started only after user interaction
Optional
Controlled through music and SFX toggles
Adjustable through a volume slider
Disabled through Mute All

Reduced Stimulation Mode disables:

Music
Confetti
Flashing effects
Intense animations
High-energy sound effects

The app remains fully usable without audio.

How I Built It With MeDo

I built OpenOdds Casino using MeDo by creating a detailed requirement-driven prompt and refining it through multiple testing passes.

The app was structured around four layers:

Game Layer

Handles virtual-credit gameplay, bet selection, win/loss results, payout calculation, and animations.
Transparency Layer

Displays probabilities, payout multipliers, expected return, house edge, and risk levels.
Audit Layer

Records every play locally and supports CSV export.
Responsible Play Layer

Provides disclaimers, warnings, reduced stimulation controls, and safe interaction rules.

MeDo helped turn this concept into a polished, interactive prototype with a strong visual identity.

Challenges Faced

The main challenge was balancing three things:

Making the app vibrant and engaging
Keeping the odds fully transparent
Avoiding real-money gambling functionality

Casino-style interfaces can easily become manipulative if they use fake urgency, jackpot language, near-miss effects, or unclear rewards.

So the design had to stay exciting without becoming misleading.

Another challenge was testing functional details like:

Reset credits
Audio controls
Local storage
Audit log updates
CSV export
Probability consistency
Mobile responsiveness
Responsible-play warnings

The app needed to look polished, but also behave correctly.

What I Learned

This project taught me that transparency can be a product feature.

A casino-style app does not have to hide the math. It can show users exactly what they are interacting with.

I also learned that serious app-building requires:

Clear requirements
Testable logic
Strong state handling
Purpose-aware QA
Edge-case testing
Responsible design boundaries
Honest user communication

The biggest lesson was simple:

A beautiful app is not enough. The logic must be visible, testable, and trustworthy.

Why This Project Matters

OpenOdds Casino is not trying to become a gambling platform.

It is a prototype showing how transparency, auditability, and responsible-play design can be built into casino-style digital experiences.

It demonstrates a future direction where users are not just entertained, but also informed.

In short:

OpenOdds Casino turns hidden odds into visible information.

Built With

MeDo
Virtual-credit game logic
Local storage
CSV export
Probability modeling
Transparent house-edge calculations
Responsible-play safeguards
Audio controls
Responsive UI design

Try the App

Try OpenOdds Casino here:

https://app-bqlx7z4f394x.appmedo.com/

Final Thought

OpenOdds Casino is a premium casino-style simulator with one core difference:

the odds are not hidden.

Every game shows the probability, the risk, the payout, and the house edge before the user plays.

That makes it more than a game demo.

It is a transparency-first experiment in responsible digital entertainment.

Love Galaxy — A Cloud 9 Love Universe Built with MeDo

PRADEEP HEBBALLI — Mon, 18 May 2026 05:56:37 +0000

Love Galaxy — A Cloud 9 Love Universe Built with MeDo

Project link: https://app-bpf6xqk7iu4h.appmedo.com/

Introduction

Love Galaxy is a dreamy, interactive love and self-love website built with MeDo.

The idea was simple: love apps should not feel like plain quote generators. They should feel emotional, visual, playful, safe, and memorable.

Love Galaxy turns small emotional moments into something users can create, save, and revisit. Users can create love notes, play romantic games, generate date ideas, save memories, explore Cloud 9 wishes, use Baby Dream Corner, and grow a personal Love Galaxy.

Why I built Love Galaxy

Most love-related apps are either too basic or too serious. Some generate messages, some provide quizzes, and some store memories. I wanted to combine these ideas into one emotional experience.

The goal was to create an app where love feels:

Beautiful
Playful
Safe
Personal
Dreamy
Repeatable

The core emotional loop is:

Create → Save → Remember → Grow

Every action should feel like a small emotional moment.

What Love Galaxy does

Love Galaxy includes multiple interactive sections:

Love Notes — create personalized romantic messages
Love Games — play romantic mini-games like Would You Rather and This or That
Date Ideas — generate date-night plans based on mood, budget, time, and location
Memory Vault — save special memories
Cloud 9 — generate wishes, promises, and future dreams
Baby Dream Corner — explore baby name dreams and future-family imagination safely
Long-Distance Mode — create messages and dream lists for long-distance love
Self-Love Corner — generate affirmations, reflections, and self-date ideas
Love Galaxy — visualize saved moments as stars, planets, moons, comets, and baby-clouds
Saved Moments — manage everything created inside the app

The Love Galaxy concept

The most important feature is the Love Galaxy itself.

Instead of simply saving text, each saved emotional moment becomes a symbolic object:

Saved Moment	Galaxy Object
Love note	Glowing planet
Memory	Star
Date idea	Moon
Game result	Comet
Cloud wish	Cloud-star
Baby dream	Baby-cloud
Promise	Constellation
Long-distance item	Shooting star
Self-love note	Crystal star

This makes the app feel more personal over time. The user is not just generating content — they are building a visual emotional universe.

How I built it

I built Love Galaxy using MeDo as a mobile-first web app.

The app was designed around:

Card-based interaction
Cloud 9 visual theme
Love Galaxy visual metaphor
Local saved moments
Safe content generation logic
Mobile-first layouts
Vibrant gradients
Soft animations
Clear copy, save, delete, and reset actions

The design uses pink, lavender, peach, coral, rose-gold, and baby-blue tones to create a dreamy Cloud 9 atmosphere.

Baby Dream Corner

One feature I wanted to add carefully was Baby Dream Corner.

This is not a pregnancy app. It does not provide fertility, medical, conception, parenting, or sex-selection advice. It is only for emotional imagination and future-family dreams.

Users can:

Save baby name ideas
Create future baby letters
Play a cute parent personality game
Generate baby-name style suggestions
Save baby dreams into the Love Galaxy

The wording is intentionally gentle, using phrases like:

One day, if life blesses us...

This keeps the feature emotional and safe without making medical or predictive claims.

Challenges

The biggest challenge was avoiding a generic love app experience.

A simple love-note generator would not be enough. To make the app more engaging, I added multiple emotional loops: games, memories, Cloud 9 wishes, Baby Dream Corner, self-love, date ideas, long-distance tools, and the Love Galaxy.

Another challenge was visual design. The app needed to feel vibrant and magical without becoming cluttered or unreadable. Clear selected states, readable text, strong contrast, and mobile responsiveness were important.

The third challenge was safety. Love apps can accidentally become possessive, obsessive, manipulative, or too intense. I designed the content logic to avoid unhealthy language and keep the tone respectful.

What I learned

I learned that emotional apps need more than functionality. They need atmosphere.

A user should not only click a button and get output. They should feel that every interaction belongs to the same emotional world.

I also learned that small UI states matter. For example, if a selected option fades too much, users may think the app is broken. Selection states must be clear, visible, and rewarding.

The project taught me that a good emotional product needs this balance:

Emotional Value = Beauty + Safety + Interaction + Memory

Accomplishments

I am proud that Love Galaxy feels like a complete emotional universe rather than a single-feature app.

The strongest parts are:

The Love Galaxy saved-moment system
The Cloud 9 visual identity
The interactive love games
The Baby Dream Corner
The self-love section
The long-distance relationship tools
The safe and respectful content boundaries
The mobile-first website experience

What's next

Next, I want to improve Love Galaxy with:

More polished galaxy animations
Better mobile navigation
More romantic mini-games
Shareable love cards
More Cloud 9 effects
More baby-name and future-dream templates
Optional export features
Stronger accessibility
More testing across devices

The long-term vision is to make Love Galaxy a beautiful emotional website where love, memories, self-love, and future dreams feel alive.

Built with

Tool	Purpose
MeDo	App building platform
Mobile-first design	Responsive website experience
Local storage concept	Saving user moments
Card-based UI	Interactive emotional flows
Cloud 9 theme	Visual identity
Love Galaxy system	Saved-moment visualization

Try Love Galaxy

Open Love Galaxy

FlowDO

PRADEEP HEBBALLI — Fri, 15 May 2026 04:59:30 +0000

FlowDo — A Private, Teen-Friendly Period Tracker and Education App

I built FlowDo as a simple, privacy-first menstrual education and period tracking app for teenagers and young users.

Try it here: https://app-bnazkps44jk1.appmedo.com/

Why I Built It

Many period tracking apps feel too complicated, too clinical, or require users to create accounts and store sensitive data online. For young users, that can be uncomfortable.

FlowDo was created with one main idea:

Period tracking should be simple, respectful, educational, and private.

The app helps users understand their cycle without forcing them to share personal information.

What FlowDo Does

FlowDo allows users to:

Log period start and end dates
Track flow, pain, mood, energy, symptoms, and notes
View a clear cycle calendar
See estimated next period dates
Learn about periods, PMS, products, myths, and when to get help
Export their own data
Reset/delete all stored data from the device

All data stays on the user’s own device. FlowDo does not require login and does not collect or share personal information.

Key Features

Private by Design

FlowDo uses local browser storage. There is no backend, no account system, and no cloud sync.

Teen-Friendly Education

The app includes simple explanations about:

Period basics
Cycle phases
PMS and self-care
Period products
Myths vs facts
When to talk to a trusted adult or healthcare professional

Clear Cycle Tracking

Users can log periods, symptoms, mood, energy, and pain. The app then shows simple insights based on the user’s own records.

Careful Predictions

FlowDo gives estimated period dates, but it clearly explains that predictions are not guaranteed. It is not medical advice and must not be used for contraception or pregnancy planning.

How I Built It

FlowDo was built as a self-contained web app using:

React
Tailwind CSS
LocalStorage
Responsive design
Client-side data export
Dynamic calendar and cycle calculations

One important part of the app was making date calculations clear. For example, a period from May 15 to May 19 should be counted as 5 days:


math
Period Duration = End Date - Start Date + 1

WeDo with MeDo

PRADEEP HEBBALLI — Fri, 15 May 2026 04:47:05 +0000

WeDo with MeDo: A Vibrant Showcase of What MeDo Can Build

I built WeDo with MeDo as a demo-only interactive showcase website to explain what users can create with MeDo.

App link: https://app-bmje20v04xs1.appmedo.com/

Why I Built This

When people hear that MeDo can help build apps, the first question is usually:

What can I actually build with it?

A normal feature list does not answer that properly. Users need examples, demos, prompts, workflows, and honest limitations.

That is why I created WeDo with MeDo — a connected showcase that turns MeDo’s capabilities into realistic app patterns.

The goal was not to create one narrow app. The goal was to create a clear, useful, and interactive guide that helps users understand how MeDo can support different types of app-building ideas.

What the App Does

WeDo with MeDo demonstrates MeDo-style app-building possibilities through:

Feature cards
Demo previews
Prompt examples
Workflow guidance
Capability mapping
Build readiness checks
Final testing reports
Truthfulness labels for mock and simulated demos

The app is intentionally demo-only. It uses sample data, mock previews, simulated AI-style content, and visual concept demos. It does not falsely claim real backend storage, real AI APIs, real payments, real email sending, real external API calls, real code export, or real deployment automation.

Key Sections

Home

The Home page introduces the project and gives users quick access to the main areas: features, demo gallery, prompt library, workflow map, and readiness checks.

Feature Explorer

The Feature Explorer shows MeDo-related capabilities such as:

Natural language app generation
UI generation
Data and CRUD workflows
Forms and validation
Business logic
Dashboards
API concepts
AI-style assistants
Productivity apps
Education apps
Workflow concepts
Build readiness planning

Each feature includes a realistic example, a truthfulness label, a related demo, and a copy-ready prompt.

Demo Gallery

The Demo Gallery contains rich preview sections for multiple app types, including:

Prompt-to-App Example Generator
Mini CRM Preview
Smart Task Manager Preview
Invoice Calculator Preview
Quiz Game Preview
AI Tutor Simulation
API Playground Mockup
Analytics Dashboard Mockup
Mini Store Preview
Smart Form Builder Preview
Workflow Builder Preview
Booking App Preview
Inventory Tracker Preview
Flashcard Learning Preview
Habit Tracker Preview

These demos are designed to make MeDo’s capabilities easier to understand through examples instead of abstract descriptions.

Prompt Library

The Prompt Library includes detailed prompts users can copy and adapt. These prompts are written to be practical, not just short one-line instructions.

They cover use cases like:

Building a CRM
Creating a dashboard
Adding a form builder
Designing an API playground mockup
Creating an invoice calculator
Building a quiz game
Planning an inventory tracker
Creating a workflow builder
Adding truthful labels
Building a testing report

App Category Gallery

The app groups ideas into practical categories:

Work & Productivity
Business & CRM
E-commerce & Payment Concepts
Learning & Education
Lifestyle & Game
Operations & Inventory
AI-Style Experiences
Creative / Experimental Apps

Each category connects to relevant demos, features, and prompts.

MeDo Workflow Map

The workflow map explains how an app idea can move from concept to a better build prompt:

Idea
Problem definition
Target user
Core feature set
Data planning
UI style
Interaction design
Mock integration planning
Testing requirements
Build readiness review
Documentation
Continuous improvement

This section helps users write clearer instructions and avoid vague prompts like “make an app.”

Capability Matrix

The Capability Matrix explains what each capability can help plan or demonstrate, what is actually shown in the website, what is not actually performed, and what truthful wording should be used.

This was important because many app-builder demos can accidentally overclaim. I wanted this project to be honest and clear.

Build Readiness Checklist

The checklist helps users review whether a demo or app concept is clear, complete, mobile-friendly, and truthfully described.

It checks areas like:

UI clarity
Content quality
Interactions
Mobile layout
Truthfulness
Documentation

Final Testing Report

The Final Testing Report checks the app itself across areas such as:

Navigation
Button behavior
Feature filters
Demo completeness
Prompt quality
Copy buttons
Calculator functionality
Quiz functionality
Responsive design
Accessibility basics
False claims
Placeholder removal
Known limitations

What I Learned

The biggest learning was that a showcase app should not just be visually attractive. It also needs strong structure.

I learned that:

Feature lists are weak unless connected to real examples.
Prompts must be detailed enough to produce useful outputs.
Mock demos can be valuable if they are clearly labelled.
Truthfulness is more important than exaggerated claims.
Buttons and navigation matter because broken connections make the app feel unfinished.
A testing report is only useful if it catches real issues like broken buttons, empty demos, and placeholders.

I also learned that keeping the app demo-only was the right decision. A previous direction with separate live/demo modes created too much complexity. The final version is simpler, clearer, and more reliable.

Challenges

The main challenge was making the app feel interactive without pretending that it was connected to real production systems.

For example:

The API Playground uses mock endpoints and responses.
The AI Tutor is a simulated AI-style demo.
The Mini Store has a simulated checkout.
The Inventory Tracker uses sample data.
The Workflow Builder shows visual logic but does not trigger real automation.

Another challenge was connecting everything properly. Home buttons, feature cards, demo links, category chips, and prompt cards all needed to point to meaningful sections.

Why This Matters

WeDo with MeDo helps users understand how to think about app-building with MeDo. Instead of starting from a blank page, users can explore realistic patterns and copy better prompts.

It is useful for:

beginners exploring app ideas
business users planning tools
students learning app design
builders looking for prompt examples
teams creating mockups or prototypes

Final Thoughts

WeDo with MeDo is a demo-only showcase, but that is its strength. It does not pretend to be a production CRM, store, AI assistant, or API platform. Instead, it clearly demonstrates how those app patterns can be planned, explained, and prompted using MeDo.

The project focuses on clarity, truthful labels, useful examples, connected navigation, and practical prompts.

Try it here:

https://app-bmje20v04xs1.appmedo.com/

MoneyFit OS

PRADEEP HEBBALLI — Wed, 13 May 2026 01:57:05 +0000

MoneyFit – A Digital Money Fitness Dashboard Built with MeDo

Introduction

Money is no longer just cash in a wallet or balance in a bank account.

Today, people interact with many forms of money: fiat currencies, bank deposits, digital payments, stablecoins, crypto assets, and cross-border currency conversions. Each option has different strengths, risks, costs, speed, stability, and use cases.

That is what inspired me to build MoneyFit.

MoneyFit is a digital money comparison and monitoring app that helps users understand different money types, compare trade-offs, monitor live currency and crypto signals, and make more informed financial decisions.

Project link:

https://app-bkzmf76og5j5.appmedo.com/

The Problem

Most users do not compare money types deeply.

They usually ask simple questions:

Which currency is moving today?
Is this stablecoin still close to its peg?
Which money type is better for saving?
Which is better for transferring?
Which is more stable?
Which has higher risk?
Which option fits my purpose?

But the answer is not always obvious.

Cash, bank money, stablecoins, crypto, and digital payments all behave differently. A tool was needed to make these differences easier to understand.

What MoneyFit Does

MoneyFit helps users compare money types in a simple, visual, and risk-aware way.

The app includes:

Money Match Engine
Live Money Health dashboard
Stablecoin Peg Monitor
Currency Converter
Compare Money Types
Currency DNA Cards
Watchlist
Global Money Map
Methodology page
Privacy and disclaimer section
Built for MeDo page

The goal is not to give investment advice. The goal is to help users understand money options more clearly.

Core Idea

MoneyFit is based on a simple idea:

Different money types are useful for different purposes.

For example:

Cash may be useful for offline spending.
Bank deposits may be useful for everyday storage.
Stablecoins may be useful for digital transfers.
Crypto may offer exposure to decentralized assets but with higher volatility.
Fiat currencies may vary based on exchange rates, inflation, and country context.

MoneyFit helps users compare these options through purpose, stability, risk, speed, and usability.

Key Features

Money Match Engine

The Money Match Engine helps users match money types to specific purposes such as:

Saving
Spending
Transferring
Holding value
Monitoring markets
Comparing risk

Instead of saying one money type is best for everyone, MoneyFit helps users think in terms of fit.

Live Money Health

The Live Money Health dashboard gives users a quick view of current money and asset signals.

It helps users understand what is happening across currencies, crypto assets, and stablecoins without overwhelming them with raw financial data.

Stablecoin Peg Monitor

Stablecoins are designed to stay close to a target value, usually one unit of fiat currency.

MoneyFit includes a stablecoin peg monitor to help users see whether a stablecoin is close to its expected value or showing possible deviation.

This is important because small peg movements can signal market stress, liquidity problems, or temporary volatility.

Currency Converter

The app includes a currency converter so users can compare values across currencies.

This helps users understand exchange differences and cross-border money movement more easily.

Compare Money Types

MoneyFit allows users to compare traditional money, fiat currencies, digital currencies, stablecoins, and crypto assets across practical dimensions such as:

Stability
Speed
Accessibility
Risk
Fees
Use case
Volatility
Trust model

Currency DNA Cards

Currency DNA Cards break down each money type into understandable traits.

Instead of showing only numbers, the cards explain how each money type behaves and what users should consider before relying on it.

Watchlist

The watchlist helps users monitor selected currencies or assets in one place.

This makes the app feel more like a personal money command center.

How I Built It

I built MoneyFit using MeDo through prompt-driven development.

MeDo helped me quickly move from concept to working app. I described the product idea, pages, dashboard structure, financial logic, live data behavior, fallback handling, and visual style, then refined the app step by step.

The build process included:

Designing the dashboard structure
Creating the Money Match Engine
Adding live data sections
Building stablecoin monitoring logic
Adding currency conversion
Creating comparison cards
Adding watchlist functionality
Designing fallback states
Adding API status indicators
Testing mobile responsiveness
Adding disclaimers and privacy sections
Refining the app so it feels vibrant and usable

MeDo made it easier to focus on the product experience instead of getting stuck at the blank-page stage.

What I Learned

I learned that financial apps need to be very careful with language.

MoneyFit should not tell users what to buy, sell, or invest in. Instead, it should help users compare options, understand trade-offs, and think more clearly.

I also learned that live financial data needs fallback handling. APIs can fail, slow down, or return unavailable data. A useful app should not break when that happens.

That is why MoneyFit includes graceful fallback handling and API status indicators.

Challenges

The biggest challenge was simplifying financial information without making it misleading.

Money and crypto are complex. A dashboard can easily become crowded or confusing. I had to organize the app into clear sections, cards, labels, and comparison tools.

Another challenge was financial responsibility. The app needed to be useful without becoming financial advice.

A third challenge was live data handling. Currency and crypto signals change quickly, so the app needed to remain understandable even when live data was unavailable.

Built With

MeDo
Prompt-driven app development
Web app interface
Live API integration
Currency conversion logic
Crypto and stablecoin data concepts
Responsive dashboard design
Fallback handling
API status indicators
Privacy and disclaimer structure

What’s Next

Future improvements could include:

More currencies and stablecoins
Historical charts
More live data providers
Personalized watchlists
Country-specific payment method comparison
Risk alerts
Better educational explainers
Stablecoin health scoring
Portfolio-neutral money planning tools
Offline fallback summaries

Final Thoughts

MoneyFit is a digital money fitness dashboard that helps users compare money types, monitor live signals, and understand financial trade-offs more clearly.

It does not try to predict the market or give financial advice.

It helps users ask better questions:

What type of money fits this purpose?
What are the risks?
How stable is it?
What trade-offs should I understand?

Using MeDo, I was able to turn this idea into a working multi-page financial dashboard with live data, fallback handling, risk-aware explanations, and a clean user experience.

Semantic Paradox

PRADEEP HEBBALLI — Tue, 12 May 2026 03:31:28 +0000

I Built Semantic Paradox with MeDo — A Fast Brain Game That Fights Your Instincts

Live app: https://app-b4mn8ezne7ep.appmedo.com/

What I built

Semantic Paradox is a high-speed Stroop-effect brain-training game built with MeDo.

The game looks simple at first: players see a color word such as RED, BLUE, GREEN, or YELLOW. But the word may appear in a different font color.

The player must follow the active rule:

HARMONY: tap the written word
PARADOX: tap the font color

The challenge is that the rule changes during the game, forcing the player to constantly switch between reading and visual recognition.

Why I built it

Most brain-training apps feel either too clinical or too repetitive. I wanted to create something that feels like a real game but still trains useful cognitive skills.

Semantic Paradox is inspired by the Stroop effect, where the brain experiences conflict between reading a word and recognizing its color. I turned that conflict into a fast 60-second challenge with scoring, feedback, leaderboard competition, and an AI-generated performance profile.

How the gameplay works

Each session lasts 60 seconds.

The player sees:

a timer
a score
the current rule: HARMONY or PARADOX
a large target word
four answer buttons: RED, BLUE, GREEN, YELLOW

Example:



If rule = HARMONY:
    correct answer = written word

If rule = PARADOX:
    correct answer = font color

Correct tap = +10 points
Incorrect tap = -5 points
Accuracy = correct taps / total taps

Decision Doppelgänger

PRADEEP HEBBALLI — Tue, 12 May 2026 03:19:13 +0000

Decision Doppelgänger – Meet Your Possible Futures

Elevator Pitch

Decision Doppelgänger simulates your future selves, compares possible choices, and helps you make smarter decisions with clearer trade-offs.

Project Link

https://app-b0nifp2dle69.appmedo.com/

About the Project

Decision Doppelgänger is an interactive decision-support app built with MeDo. It helps users explore important choices by simulating different versions of their future self.

The idea was inspired by a question everyone faces:

What would happen if I chose a different path?

Every major decision creates multiple possible futures. One version of you accepts the job. Another starts the business. Another waits. Another moves city, changes career, studies a new skill, rejects the offer, or takes the risk.

Decision Doppelgänger turns that idea into a structured reflection tool. Instead of giving a simple yes or no answer, the app helps users compare possible choices through future-self perspectives, trade-offs, benefits, risks, regrets, opportunities, and long-term consequences.

The goal is not to predict the future perfectly. The goal is to help users think more clearly before making important decisions.

What It Does

Decision Doppelgänger helps users compare possible decisions by generating different “future selves” for each option.

Users can:

Enter a decision they are facing
Add multiple possible choices
Compare future outcomes
View emotional, financial, career, lifestyle, and risk impacts
Generate future-self perspectives
Identify hidden trade-offs
Reflect on regret potential
See which option aligns best with their priorities

The app is useful for decisions such as:

Should I accept this job?
Should I quit and start a business?
Should I move to another city?
Should I learn a new skill?
Should I take a risky opportunity?
Should I choose stability or growth?

The core idea is:

Better decisions come from seeing the trade-offs clearly.

A simple way to think about the app’s decision model is:



Decision Fit = Benefits + Personal Alignment - Risks - Regret Potential

SafeReach AI

PRADEEP HEBBALLI — Tue, 12 May 2026 03:10:26 +0000

SafeReach AI – Global Scam & Crisis Safety Assistant

Elevator Pitch

SafeReach AI helps users detect scam-risk indicators, follow crisis guidance, use safety chat, and generate family alerts in Live Safety Mode.

Project Link

https://app-bg447rmtqhhd.appmedo.com/

About the Project

SafeReach AI is a global no-login safety assistant built with MeDo for seniors, families, caregivers, migrants, travelers, and vulnerable users.

The project was inspired by a real and serious problem: during emergencies, people often face two risks at the same time — the crisis itself and scams that exploit fear, urgency, and confusion.

A person may receive a message about bank verification, flood relief, hospital payment, government aid, emergency donation, or a family member in danger. In stressful situations, it can be difficult to know what is real, what is risky, and what action to take next.

SafeReach AI was built to help users answer one urgent question:

Is this message risky, and what should I do safely right now?

What It Does

SafeReach AI includes:

Live Safety Mode for real user-entered messages and crisis guidance
Demo Mode for sample scam and crisis scenarios
Scam-risk message analyzer
Guided Safety Chat Assistant
Crisis Navigator with step-by-step emergency guidance
Senior Mode with large, simple action buttons
Emergency Wallet Card generator
Family Alert Generator
Self-Help Safety Center
Country Safety Packs
Privacy-safe local analytics

The scam analyzer uses rule-based risk scoring to identify indicators such as:

OTP, PIN, password, or CVV requests
Bank/KYC verification pressure
Suspicious links
Urgent payment requests
Fake relief or government aid claims
Fake charity or donation requests
Family emergency pressure
Instructions not to call family, police, or banks

Instead of saying a message is definitely a scam, SafeReach AI uses safer language:

This message shows scam-risk indicators.

This keeps the app responsible while still giving practical safety guidance.

Inspiration

The inspiration came from real-world scam patterns that target vulnerable people, especially during emergencies.

Scammers often send messages like:

“Your bank KYC is expired. Enter OTP now.”
“Flood relief approved. Pay a processing fee.”
“Your son is in hospital. Send money immediately.”
“Government aid available. Upload your ID and bank details.”
“Donate now to an official rescue team.”

These messages combine urgency, emotion, money, and confusion. SafeReach AI slows the user down, highlights red flags, and guides them toward safer action.

How I Built It

I built SafeReach AI using MeDo through prompt-driven development and iterative testing.

MeDo helped turn a complex safety concept into a working web app by allowing me to describe the product structure, user flows, safety rules, UI behavior, and demo scenarios step by step.

The build process included:

Designing the Live Safety Mode and Demo Mode structure
Creating a global country and language selector
Building the suspicious message analyzer
Adding rule-based scam-risk scoring
Creating crisis guidance flows
Designing a senior-friendly interface
Adding a guided safety chat assistant
Creating emergency wallet card and family alert tools
Adding privacy-safe analytics
Testing the app for mobile usability, safe behavior, and clear disclaimers

MeDo was especially useful for rapid iteration. I could test the app, identify weak points, and improve the experience through follow-up prompts.

One important refinement was changing the app from a demo-only concept into a usable product with Live Safety Mode as the default and Demo Mode as an optional walkthrough mode for judges and testing.

What I Learned

I learned that safety apps must be designed differently from normal productivity apps. Users may be stressed, confused, elderly, or in danger, so the interface must be calm, simple, and direct.

I also learned the importance of responsible boundaries. SafeReach AI does not contact emergency services, does not diagnose medical problems, does not give legal advice, and does not guarantee scam detection. Instead, it provides structured safety guidance and encourages users to verify through trusted people and official channels.

I also learned how powerful prompt-driven development can be for building multi-feature apps quickly. MeDo helped me focus on product thinking: what the user sees, what they click, what they understand, and how safely the app behaves.

Challenges I Faced

The biggest challenge was balancing usefulness with safety.

A scam and crisis app must be helpful, but it must not overclaim. I had to carefully design the wording so the app says “risk indicators” instead of “confirmed scam.”

Another challenge was avoiding a demo-only experience. The app originally focused heavily on sample scenarios, but I refined it so users can actually paste their own messages and use Live Safety Mode.

A third challenge was making the app senior-friendly. That required large buttons, simple text, clear warnings, and direct actions like:

I Am Safe
Do Not Share OTP/PIN
I Received Money Request
Ask Safety Assistant
Create Emergency Card

The goal was to reduce confusion and make safer action easier.

Built With

MeDo
Prompt-driven app development
Web app interface
Rule-based risk scoring
Responsive UI design
Local app state
Privacy-first no-login structure
Guided safety chat logic
Global country safety packs
Live Mode and Demo Mode workflows

Key Features

Live Safety Mode

Users can paste their own suspicious message, select their country and language, and receive scam-risk indicators, red flags, safe next steps, and a family alert template.

Demo Mode

Judges and users can run preloaded scam and crisis scenarios to understand how the app works.

Guided Safety Chat

A rule-based assistant helps users navigate situations like suspicious messages, money requests, crisis steps, senior support, and family alerts.

Crisis Navigator

Users can select crisis types such as flood, heatwave, earthquake, fire, medical emergency, cyber scam, evacuation, or power outage and receive structured guidance for:

First 10 minutes
First 1 hour
Next 24 hours

Senior Mode

A simplified interface with large buttons helps seniors take quick actions without navigating complex screens.

Emergency Wallet Card

Users can create a local emergency card with key details, emergency contacts, medical notes, and safety reminders.

Privacy-Safe Analytics

The app tracks local interaction counts for product feedback without storing raw user messages.

What’s Next

Future improvements could include:

Offline crisis safety packs
More countries and languages
Voice/audio mode for low-literacy users
Verified local safety partners
NGO/admin safety content dashboard
Official emergency alert integrations
Encrypted emergency card storage
Caregiver sharing mode
More advanced scam-pattern detection
Accessibility improvements for seniors and disabled users

Final Summary

SafeReach AI is a global no-login safety assistant that helps users detect scam-risk indicators, follow crisis guidance, use guided safety chat, generate family alerts, and create emergency wallet cards.

Using MeDo, I was able to transform a complex public-safety idea into a working web app with Live Safety Mode, optional Demo Mode, senior-friendly design, and privacy-safe local analytics.

XenoLexis

PRADEEP HEBBALLI — Tue, 12 May 2026 02:55:19 +0000

XenoLexis – The Xenolinguistics Lab

Elevator Pitch

XenoLexis is a first-contact decoding lab where users analyze alien signals, uncover language patterns, and translate the unknown through frequency, grammar, and logic.

Project Link

https://app-bdk4u6bmkphd.appmedo.com/

About the Project

XenoLexis is an interactive xenolinguistics lab built with MeDo. The project is inspired by the idea of first contact: what if humanity received an unknown alien transmission and had to decode it from scratch?

Instead of presenting translation as a simple text conversion task, XenoLexis turns language decoding into a structured reasoning experience. Users explore alien-style signals, analyze symbol patterns, inspect frequency clues, interpret grammar hints, and gradually move from mystery to meaning.

The app is designed to feel like a sci-fi research console while teaching real analytical ideas such as pattern recognition, symbolic reasoning, frequency analysis, and language structure.

The core idea is simple:

Language is not only vocabulary. It is repetition, probability, grammar, context, and structure.

The decoding logic is inspired by frequency analysis. If one symbol appears again and again, it may represent a common word, repeated concept, or grammatical marker. XenoLexis turns that idea into an interactive first-contact puzzle.

What It Does

XenoLexis lets users enter a futuristic decoding lab where they can:

Start a new alien signal
Try a practice signal
Analyze alien-style language patterns
Explore symbol repetition and frequency clues
Interpret grammar and structure hints
Use pattern recognition to move toward translation
Experience a cinematic sci-fi interface
Learn analytical thinking through interactive play

Inspiration

The project was inspired by science fiction, cryptography, linguistics, and the mystery of unknown communication systems.

I wanted to create an app that makes users feel like they are part of a first-contact research team decoding an alien language for the first time. The goal was to make learning feel like a mission, not a lesson.

How I Built It

I built XenoLexis using MeDo, which helped me turn the idea into a working web app through prompt-driven development.

MeDo made the build process faster and more visual. I described the product concept, user flow, visual direction, and required interactions, then refined the app step by step. Instead of starting from a blank development setup, I used MeDo to rapidly move from idea to prototype to a polished interactive experience.

The development process included:

Defining the xenolinguistics concept
Creating the sci-fi landing page
Building the signal-starting flow
Adding a practice signal mode
Designing the frequency-analysis-inspired experience
Refining the hero section and action buttons
Improving the layout for desktop and mobile
Removing unnecessary elements that distracted from the main experience
Testing the app flow for clarity and usability

MeDo was especially useful for rapid iteration. I could test the app visually, identify what felt confusing, and improve the design through follow-up prompts. For example, I refined the landing page, simplified the main actions, and removed unnecessary UI so users could focus on the decoding experience.

What I Learned

I learned that a strong educational app does not need to look like a classroom. It can feel like a game, a mission, or a research simulation.

I also learned how useful prompt-driven development can be when building creative products quickly. MeDo helped me focus on product thinking: what the user sees, what they click, what they understand, and how the experience feels.

I learned the importance of balancing:

Visual atmosphere
Usability
Educational value
Clear interaction flow
Minimal but meaningful UI
Fast iteration through MeDo prompts

A sci-fi interface can easily become too decorative, so I focused on keeping the main actions clear: start a new signal or try a practice signal.

Challenges I Faced

One challenge was making the concept easy to understand quickly. “Alien language decoding” is exciting, but the user still needs to immediately understand what the app does and where to click.

Another challenge was keeping the interface visually rich without overcrowding it. I refined the layout, removed unnecessary elements, and focused the hero section around the core decoding experience.

A third challenge was translating a fictional concept into a usable interface. The app needed to feel mysterious, but not confusing. It needed to look cinematic, but still work clearly as an interactive learning tool.

MeDo helped by allowing fast design and functionality refinement. I could adjust the interface, test the flow, and improve the experience without rebuilding everything from scratch.

Built With

MeDo
Prompt-driven app development
Web app interface
Responsive UI design
Procedural language concept design
Frequency-analysis-inspired logic
Sci-fi visual design
Iterative UI refinement

What’s Next

Future improvements could include:

More alien species and language families
Deeper grammar puzzles
Translation scoring
Progressive difficulty levels
Audio signal decoding
Achievement badges
Mission-based campaign mode
Leaderboard or decoding accuracy score
More guided educational explanations inside the decoding lab

Final Summary

XenoLexis is a first-contact language decoding experience that combines sci-fi storytelling with educational pattern recognition. It helps users think like linguists, cryptographers, and explorers while decoding the unknown.

Using MeDo, I was able to rapidly transform a creative concept into a polished interactive web app with a strong visual identity and a clear learning experience.

FP&A Command Center

PRADEEP HEBBALLI — Tue, 12 May 2026 02:04:31 +0000

FP&A Command Center AI Ultra

Elevator Pitch

FP&A Command Center AI Ultra is a local-first AI-enabled Financial Planning & Analysis command center for planning, forecasting, variance analysis, financial statements, CSV uploads, templates, exports, and live data workflows — no login or backend required.

App Link

https://app-bjcv8bavb401.appmedo.com/

Inspiration

The project was inspired by the gap between spreadsheets and enterprise FP&A platforms.

Spreadsheets are flexible, but they become fragile as planning models grow. It becomes difficult to manage data quality, assumptions, versions, templates, calculations, and outputs reliably.

Enterprise FP&A tools such as Anaplan, Oracle EPM, OneStream, and Workday Adaptive Planning are powerful, but they are expensive, implementation-heavy, and usually require enterprise infrastructure.

I wanted to build something between these two worlds: a lightweight FP&A command center that feels structured like an enterprise planning tool but runs locally in the browser.

The goal was not to replace enterprise EPM systems. The goal was to make core FP&A workflows easier to learn, test, and use.

Built With MeDo

This project was built using MeDo, which helped turn a complex FP&A product idea into a working browser-based application.

MeDo was used to rapidly generate, test, refine, and improve the app across multiple development cycles. The project went through many iterations, including building the dashboard, planning modules, editable grids, upload system, template library, Demo Mode, Live Mode, financial statement logic, exports, and AI Finance Copilot support.

One of the biggest advantages of using MeDo was the ability to move quickly from idea to working prototype, then continue improving the app through testing and issue fixing. Instead of only describing the product, I could build and refine actual workflows.

MeDo helped with:

Generating the initial app structure
Building the FP&A module layout
Creating dashboards and planning pages
Adding Demo Mode and Live Mode
Creating editable planning grids
Implementing CSV templates and upload flows
Adding local browser persistence
Building financial statement pages
Improving exports and validation
Iterating through bugs and fixes quickly

The project also showed that even with AI-assisted building, serious testing is still necessary. Page loading is not enough. A finance app must prove that inputs produce correct outputs.

What It Does

FP&A Command Center AI Ultra helps users move from financial inputs to planning outputs.

The app includes:

Executive Dashboard
Demo Mode with sample FP&A data
Live Mode for user-entered or uploaded data
CSV upload and mapping
Template Library
Revenue Planning
COGS Planning
OPEX Planning
Headcount Planning
CAPEX Planning
Working Capital Planning
Budgeting
P&L Statement
Balance Sheet
3-Statement Model
Forecasting
Variance Analysis
Data Quality and Anomaly Center
AI Finance Copilot support
Export functionality
Browser-based local persistence

Demo Mode and Live Mode

One important design decision was separating Demo Mode and Live Mode.

Demo Mode allows users to explore the platform with sample financial data. It helps users understand dashboards, statements, forecasts, and analysis before using their own data.

Live Mode allows users to manually enter planning data or upload CSV files. Live Mode is designed to stay separate from Demo Mode so users know whether they are viewing sample data or their own data.

This matters because finance tools must be honest about data source.

Upload and Template System

The app includes templates for structured FP&A inputs.

Templates include:

Company Setup
Planning Calendar
Chart of Accounts
Dimensions
Assumptions
Driver Library
Revenue Planning
COGS Planning
OPEX Planning
Headcount Planning
CAPEX Planning
Working Capital
Cash Flow
Balance Sheet
Budget vs Actual
Forecast
Trial Balance
General Ledger
KPI
Product Profitability
Customer Profitability
Scenario Assumptions
Workflow / Approval
Audit Trail Import
Report Input
AI Finance Copilot Prompt Template

The intended workflow is:

Choose the relevant template
Download the CSV
Fill or modify the sample data
Upload the file
Map and validate fields
Import into Live Mode
Review dashboard and statement outputs

Financial Logic

The app is built around core FP&A calculations.

Revenue Planning

Revenue = Units × Price × (1 - Discount %)

Example:

Units = 100
Price = 1,000
Discount = 0%

Revenue = 100 × 1,000 × (1 - 0%)
Revenue = 100,000

Gross Profit and Gross Margin

Gross Profit = Revenue - COGS

Gross Margin % = Gross Profit / Revenue × 100

Example:

Revenue = 100,000
COGS = 60,000

Gross Profit = 100,000 - 60,000
Gross Profit = 40,000

Gross Margin % = 40,000 / 100,000 × 100
Gross Margin % = 40%

EBITDA

EBITDA = Gross Profit - OPEX

Example:

Gross Profit = 40,000
OPEX = 25,000

EBITDA = 40,000 - 25,000
EBITDA = 15,000

EBIT and Net Profit

EBIT = EBITDA - Depreciation

Profit Before Tax = EBIT - Interest Expense

Tax = max(0, Profit Before Tax × Tax Rate)

Net Profit = Profit Before Tax - Tax

Working Capital

Working Capital = Receivables + Inventory - Payables

Example:

Receivables = 50,000
Inventory = 30,000
Payables = 20,000

Working Capital = 50,000 + 30,000 - 20,000
Working Capital = 60,000

Free Cash Flow

Free Cash Flow = Operating Cash Flow - CAPEX

Example:

Operating Cash Flow = 40,000
CAPEX = 10,000

Free Cash Flow = 40,000 - 10,000
Free Cash Flow = 30,000

Closing Cash

Closing Cash = Opening Cash + Operating Cash Flow - CAPEX + Financing Cash Flow

Example:

Opening Cash = 100,000
Operating Cash Flow = 40,000
CAPEX = 10,000
Financing Cash Flow = 0

Closing Cash = 100,000 + 40,000 - 10,000 + 0
Closing Cash = 130,000

Variance Analysis

Variance = Actual - Budget

Variance % = (Actual - Budget) / Budget × 100

Example:

Actual Revenue = 100,000
Budget Revenue = 120,000

Variance = 100,000 - 120,000
Variance = -20,000

Variance % = -20,000 / 120,000 × 100
Variance % = -16.67%

For revenue, a negative variance is unfavorable. For costs such as OPEX or COGS, a lower actual value can be favorable.

Forecasting

Naive Forecast = Last Actual Value

Moving Average = Average of recent periods

Weighted Forecast = Recent Month × 50% + Previous Month × 30% + Earlier Month × 20%

Example:

March Revenue = 140,000
February Revenue = 120,000
January Revenue = 100,000

Weighted Forecast = 140,000 × 50% + 120,000 × 30% + 100,000 × 20%
Weighted Forecast = 126,000

Anomaly Detection

The app flags unusual financial movements using threshold rules.

Examples:

Revenue drop greater than 20% = anomaly
OPEX increase greater than 15% = anomaly
CAPEX increase greater than 25% = anomaly
Gross margin drop greater than 5 percentage points = anomaly

AI Finance Copilot Support

The AI Finance Copilot section is designed to help users structure finance analysis and management commentary.

It supports use cases such as:

Variance explanation
CFO summary
Forecast commentary
Cash risk review
OPEX challenge
Revenue driver analysis
Board-pack narrative
Anomaly explanation
Scenario recommendation
Management action planning

The app also includes an AI Finance Copilot Prompt Template so users can structure finance questions clearly.

How I Built It

The project was built as a local-first browser app using MeDo.

The main design principles were:

Keep data local to the browser
Avoid login and backend complexity
Separate Demo Mode and Live Mode
Use templates for structured data input
Convert planning inputs into financial facts
Preserve dimensions such as product, customer, channel, entity, department, and account
Show outputs through dashboards, statements, forecasts, and exports
Make financial logic traceable

The core workflow is:

Input Data → Mapping → Validation → Financial Facts → Calculations → Dashboard / Reports / Exports

Challenges I Faced

The hardest part was not creating screens. The hardest part was making the workflows connected and honest.

Some of the key challenges were:

Preventing Demo Mode and Live Mode from mixing data
Making sure Live Mode does not silently show demo data
Ensuring uploaded dimensions such as product, customer, channel, department, and entity are preserved
Avoiding duplicate facts when users save or upload the same data repeatedly
Making validation specific to the selected upload type
Ensuring financial calculations match expected results
Making exports clearly show Demo or Live mode
Adding AI Finance Copilot support without overclaiming fake AI capability

This forced the project to move beyond page-load testing. A finance app should not only load pages. It must prove that inputs produce correct outputs.

Input → Processing → Output → Expected Result

What I Learned

This project made one thing very clear: FP&A software is mostly about data integrity, not dashboards.

A dashboard is useful only if the input data is mapped correctly, the calculations are traceable, and the output can be trusted.

I also learned that local-first apps can be powerful for finance learning and prototyping. Users can explore planning workflows without needing cloud infrastructure, login systems, or enterprise setup.

The most important lesson was that testing must be based on expected versus actual outputs, not only screenshots.

I also learned that MeDo can accelerate app creation significantly, but the builder still needs strong product thinking, detailed prompts, ruthless testing, and clear acceptance criteria.

Current Status

FP&A Command Center AI Ultra is being submitted as a Hackathon Release Candidate.

It is suitable for:

Hackathon demonstration
FP&A education
Lightweight financial analysis
Small-business planning
Consulting demos
Workflow prototyping

It is not positioned as a full enterprise EPM replacement.

Known Limitations

Some areas still need future improvement:

Some configuration templates may be download/manual-reference only
Some upload workflows may need additional parser hardening
Users should manually validate outputs before using them for high-stakes financial decisions
Enterprise features such as multi-user roles, approval workflows, ERP integration, and cloud database persistence are outside the current scope

Final Thought

FP&A Command Center AI Ultra is an attempt to make financial planning and analysis more accessible.

It combines templates, uploads, manual planning, financial statements, forecasting, variance analysis, exports, and AI-assisted finance thinking into one browser-based app.

The project is not trying to replace enterprise finance systems. It is trying to make the FP&A workflow easier to learn, test, and use.

Try the app here: FP&A Command Center AI Ultra

SupplyShock Sentinel

PRADEEP HEBBALLI — Tue, 12 May 2026 01:43:59 +0000

Building SupplyShock Sentinel with MeDo: An AI Control Tower for Supply Chain Risk

Supply chains usually fail quietly before they fail visibly.

A supplier delay starts as a small update. Inventory drops below a safe level. A Tier-2 supplier gets disrupted. A purchase order moves from “confirmed” to “delayed.” By the time the business notices, the problem may already have turned into a customer delivery failure.

That is the problem I wanted to solve with SupplyShock Sentinel.

Live app: https://app-bfiq7qjaez9d.appmedo.com/

What is SupplyShock Sentinel?

SupplyShock Sentinel is an AI-powered supply-chain risk analysis and decision-support platform for small and mid-sized businesses.

It helps users answer one simple but important question:

What will fail first, why will it fail, and what should we do now?

The app allows users to upload supply-chain data, validate it, analyze it, simulate disruptions, and generate recovery actions.

Users can either:

try built-in demo data
upload their own CSV files

Supported data types include:

Purchase Orders
Suppliers
Inventory
Supplier Relationships
Alerts

Why I built it

Many small and mid-sized businesses still manage supply-chain operations using Excel, email, WhatsApp, and manual follow-ups.

That creates major blind spots:

supplier delays are discovered too late
inventory stockouts are not predicted early
supplier reliability is not quantified
Tier-2 and Tier-3 dependencies are invisible
teams do not know what to fix first
financial exposure is not estimated before disruption

Most enterprise supply-chain control towers are expensive and complex. I wanted to build a lighter, accessible version that a smaller business could understand and use quickly.

How MeDo helped

I built the app using MeDo, an AI-powered app-building platform that helps generate full-stack web applications through natural language prompts.

MeDo made the process much faster because I did not need to manually build every page, route, form, table, and dashboard from scratch.

Instead, I could describe the app as a product:

what pages it needed
what data structures it should use
what the upload flow should look like
how risk scoring should work
how dashboards should react
how users should edit data
how what-if scenarios should work

Then I could test, find gaps, and ask MeDo to improve specific parts.

The biggest benefit was iteration speed.

The app started as a dashboard idea. After testing, I realized that a dashboard alone was not enough. Users needed a clear upload workflow. So I used MeDo to add:

CSV template downloads
required header explanations
upload preview
row-level validation
import controls
reactive dashboard updates
data editing
what-if scenario testing
Help and About pages

MeDo helped turn the project from a demo into a usable product experience.

Core workflow

The app follows this journey:

Open the app.
Choose Try Demo Data or Upload Your Own Data.
Review required CSV formats.
Download sample templates.
Upload supply-chain data.
Preview and validate uploaded rows.
Confirm import.
Run Sentinel Analysis.
View dashboards and alerts.
Edit data or run what-if scenarios.
Ask AI Copilot what to fix first.
Download risk-scored CSV files and reports.

This was important because a first-time visitor should not need external explanation to understand the app.

Risk scoring logic

The app uses an explainable risk scoring model.


text
Risk Score = Inventory Risk + Supplier Risk + Delay Risk + Priority Risk + Status Risk + Deep-Tier Risk