DEV Community: Chieloka Madubugwu

Golden Circle - A app for the Elderly users

Chieloka Madubugwu — Sun, 01 Mar 2026 12:45:35 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

GoldenCircle was created to address a growing global challenge faced by aging populations — the silent epidemic of social isolation among elderly individuals. Many seniors experience loneliness not because they are unwilling to connect, but because modern digital environments often exclude them. Physical mobility limitations, declining social circles after retirement, and the death of long-time partners or friends can gradually shrink daily social interaction. Over time, this can lead to emotional withdrawal and decreased life satisfaction.

Loneliness among elderly populations is strongly associated with increased risks of depression, cognitive decline, and poorer cardiovascular health. Psychological research suggests that consistent social stimulation and emotional validation play a critical role in healthy aging. However, most social media platforms are optimized for fast, visually dense, youth-oriented communication styles.

GoldenCircle was intentionally designed as an inclusive digital environment where technology adapts to the user rather than forcing the user to adapt to technology. The platform emphasizes comfort, clarity, and emotional safety. Interface elements are deliberately simplified, with large readable typography, minimal clutter, and predictable interaction flows. Instead of overwhelming users with hundreds of features, GoldenCircle focuses on meaningful interactions that support daily emotional wellbeing

What I Built

GoldenCircle is an AI-powered emotional wellness and communication platform specifically engineered for elderly users. Unlike conventional messaging applications, which prioritize speed and information exchange, GoldenCircle prioritizes emotional continuity, companionship, and cognitive comfort.

The platform is built around three foundational pillars: connection, comfort, and joy. Each pillar is translated into practical features that are easy to use while still delivering meaningful psychological benefits.

1. Real-Time Chat Rooms (Connection)
The real-time chat room system allows seniors to interact with friends or community members using a simple 8-digit room joining mechanism. This design removes the need for complicated friend requests, search systems, or long profile configurations.

The interface uses large visual targets and readable contrast ratios to support users with declining vision. Messages are delivered through WebSocket-based streaming, ensuring that conversations feel natural and alive without requiring page refreshes.

Communication is enhanced through AI-assisted emoji suggestions. When a user types or speaks a sentiment, the system recommends appropriate emoji representations to help users express emotional states more easily. For example, a user expressing gratitude may be gently presented with a heart or smile icon. Each emoji also includes a tap-to-learn explanation feature, which is particularly helpful for users who are unfamiliar with modern digital symbolism.

2. Daily AI Companion (Comfort)
The Daily Companion transforms GoldenCircle from a simple communication platform into a digital emotional presence that accompanies the user throughout the day.

Upon opening the app, users are greeted with gentle voice-based interaction. The companion asks simple conversational prompts such as “How are you feeling today?” or “Did you sleep well last night?” These prompts are intentionally non-demanding, allowing users to respond at their own pace. The system supports voice input using browser speech interfaces, which is particularly beneficial for seniors who may find typing difficult.

Users can optionally record their daily mood, which helps the system generate more supportive responses in future interactions. The companion also provides gentle wellness reminders such as hydration prompts, medication timing suggestions, or encouragement to perform light physical movement.

Positive affirmation messages are delivered carefully to avoid sounding mechanical or overly artificial. The goal is not to simulate human relationships but to provide consistent emotional reassurance during periods of solitude. For many elderly individuals living alone, the companion acts as a comforting conversational anchor during quiet daytime hours.

3.Golden Memories – Time Machine (Fun & Nostalgia)
The Golden Memories Time Machine is one of the most emotionally significant features of the platform. Users can travel through selected decades ranging from the 1950s to the 1990s and explore culturally familiar content.

Nostalgia has strong psychological benefits because it activates reward-associated neural pathways linked to positive autobiographical memory recall. When seniors engage with memories from their youth, it can trigger dopamine release and promote feelings of identity continuity.

Within the Time Machine, users can listen to music styled after their chosen era, read popular sayings, or explore historical trivia. The system also offers short interactive quizzes framed as playful questions such as “Do you remember what people used to call television remotes in the 1970s?”

GoldenCircle therefore evolves beyond a messaging tool into a holistic emotional ecosystem. It acts as a companion, memory archive, and safe social environment where elderly users can interact at their own pace

Demo

Golden Circle Demo by Chieloka Madubugwu

Public Url: https://golden-circle-olive.vercel.app/

Code

Github code: https://github.com/ChielokaCode/Golden-Circle

The project repository demonstrates a modular software architecture designed for scalability and maintainability.

Frontend

The frontend is built using React with TypeScript to enforce strict component typing and reduce runtime errors. TailwindCSS is used to ensure accessibility-first responsive design. Styling choices prioritize large touch targets, high contrast readability, and soft visual transitions.

The Web Speech API is integrated into the Daily Companion module to support voice-based interaction.

Backend

The backend is implemented using Node.js and Express to provide RESTful API services. Real-time communication is powered by WebSocket streaming through a lightweight messaging server.

Artificial intelligence services are integrated into multiple endpoints. These include:

Emotionally aware response generation that adjusts tone based on user mood signals.
Nostalgia content synthesis for Time Machine exploration.
Quiz generation tailored to selected historical decades.

How I Built It

GoldenCircle was developed using accessibility-first engineering principles.

On the frontend, React with TypeScript provides component reliability and maintainability. TailwindCSS enables rapid yet consistent UI construction while preserving readability for elderly users. Voice interaction is supported through browser speech recognition technologies, reducing dependence on typing.

State management favors lightweight persistence using browser storage for non-sensitive data. This design choice keeps the application responsive even on low-end devices.

On the backend, Node.js with Express provides flexible API routing and easy integration with AI inference services. WebSocket broadcasting ensures that conversations remain synchronized in real time.

AI services power emotional response synthesis, nostalgia generation, and quiz creation. The system is carefully tuned to avoid overly anthropomorphic behavior while still providing warm conversational experiences.

Product Expiry Tracker AI with KendoReact

Chieloka Madubugwu — Wed, 19 Mar 2025 07:45:11 +0000

This is a submission for the KendoReact Free Components Challenge.

What I Built
Demo
Video Demo
KendoReact Experience
KendoReact Free Components Used
AIm to Impress
AI Integration Pictures

What I Built

Product Expiry Tracker AI is an application built on React that helps users monitor the expiry dates of their products. It can be used widely in Supermarkets, drug stores and malls to enable users get real time assessment of their products details. The issue of products expiring on shelves is becoming alarming therefore the need to acquire this application. This Expiry Tracker AI is a real world application that solves real problems and it is powered by React and includes at least 10 KendoReact free Components. This project was built from scratch within the time frame of this challenge.

The project integrates AI to give summaries of product details in the inventory, together with actionable steps to prevent expiry of the product. The AI can also scan product details and add products to the inventory automatically without needing to fill the form.

A key feature is the expiration products page, which lists products nearing expiration within two months or more, helping customers track items close to expiry. This page uses Kendo React grid components with pagination and filtering options. Users can print and export product lists as PDFs, selecting specific columns via checkboxes.

Demo

This Application utilizes Authentication but feel free to use dummy data (Email and password) to register and login.

The Application is built on React for the frontend and includes 10 or more KendoReact free components which I will list out below

Public Url:
Github code:

App Screenshots

Video DEMO

KendoReact Experience

KendoReact Free Components is a game changer used to design and develop business applications with React. It has over 50+ free components in which I used the under listed for this project. It really shaped my user experience flow due to its great UI and its heavy use in this project helped me to do so much with so little code. I just had to pick the component and customize the props to fit the project.

KendoReact Free Components Used

1 Kendo Label and Input components

import { Label } from "@progress/kendo-react-labels";
import { Input } from "@progress/kendo-react-inputs";

<Label className="font-medium" editorId="firstName">
 First Name&nbsp;
</Label>
<Input
  id="firstName"
  disabled
  name="firstName"
  type="text"
  value={firstName}
  onChange={}
/>

2 Kendo DatePicker

import { DatePicker } from "@progress/kendo-react-dateinputs";
<DatePicker
  className=""
  name="dob"
  value={dob}
  onChange={}
/>

3 Kendo DropdownList

import { DropDownList } from "@progress/kendo-react-dropdowns";
<DropDownList
  style={{
  width: "390px",
 }}
 data={sex}
 value={gender}
 defaultValue="Male"
 onChange={}
 name="gender"
/>

4 Kendo Notification

import { Notification } from "@progress/kendo-react-notification";
<Notification closable={true} type={{ style: "error", icon: true }}>
 {error}
</Notification>

5 Kendo Toolbar, ToolbarSeperator, Button and ButtonGroup

import {
  Toolbar,
  ToolbarSeparator,
  Button,
  ButtonGroup,
} from "@progress/kendo-react-buttons";
<Toolbar>
  <ButtonGroup>
    <Button
      className="k-toolbar-button"
      svgIcon={boldIcon}
      title="Bold"
      onClick={() => onFormat("bold")}
    />
</ButtonGroup>
</Toolbar>

6 Kendo Grid, GridColumn

import { Grid, GridColumn as Column } from "@progress/kendo-react-grid";
<Grid>
   <Column field="id" title="ID" filterable={false} width="40px" />
   <Column field="productName" title="Product Name" width="240px" />
</Grid>

7 Kendo Dialog, DialogActionBar

import { Dialog, DialogActionsBar } from "@progress/kendo-react-dialogs";
<Dialog title={"Please confirm"} onClose={toggleDialog}>
  <p style={{ margin: "25px", textAlign: "center" }}>
    Actions for {selectedProduct.productName}
  </p>
 <DialogActionsBar>
    <Button themeColor="info">
     Edit
    </Button>
</DialogActionsBar>
</Dialog>

8 Kendo Checkbox

import { Checkbox } from "@progress/kendo-react-inputs";
 <Checkbox
    type="checkbox"
    id={}
    name={}
    defaultChecked={}
    onChange={}
    label={}
 />

9 Kendo Card, CardTitle, CardBody

import { Card, CardBody, CardTitle } from "@progress/kendo-react-layout";
<Card style={{ width: 300 }} type="info">
  <CardBody>
    <CardTitle>Total Products</CardTitle>
       <p>Number of products in the system.</p>
    </CardTitle>
  </CardBody>
</Card>

10 Kendo ProgressBar

import { ProgressBar } from "@progress/kendo-react-progressbars";
<ProgressBar value={productLength} />

11 Kendo FloatingActionButton

import { FloatingActionButton } from "@progress/kendo-react-buttons";
<FloatingActionButton
   svgIcon={open ? cancelIcon : homeIcon}
   items={navLinks}
   item={CustomItem}
   positionMode="absolute"
   modal={true}
   onOpen={handleOpen}
   onClose={handleClose}
/>

AIm to Impress

I integrated AI technology with OpenAI.

Here users can ask the AI questions relating to the products in the inventory/database such as to get all product expiring dates, summarize products close to expiry, actionable steps and with the help of the product quantity predict products that should be understocked or overstocked in the next purchase.
Users can also scan product details through the use of the camera and the AI will be able to deduce the Product Information from the image, then a Kendo Button had been added so as if the user is satisfied with the AI output, the product will then be saved to the database. This is a shortcut to the stress of individually filling the "Add Product" form

AI Integration Pictures

A Guide to Quickly Deploying and Interacting with Smart Contracts Using the Stellar CLI

Chieloka Madubugwu — Sat, 17 Aug 2024 12:10:51 +0000

This is a submission for the Build Better on Stellar: Smart Contract Challenge : Create a Tutorial

Overview
Tools to have before coding
Goal for this Tutorial
Glossary
Programming Language used
STEPS to follow
Video Explanation
What I Created
Journey

Overview

My Submission will explain in depth on how to properly use the Stellar CLI Commands to build, deploy and Interact with the smart contracts.
The Stellar CLI is the command line interface to Soroban smart contracts. It allows you to build, deploy, and interact with smart contracts; configure identities; generate key pairs; manage networks; and more.

For this Tutorial, i will take you by the hand as a complete beginner to coding to deploying and interacting with the smart contract via command line

Tools to have before coding

Install Node latest version or v18
Install Visual Studio Code
Have a good Internet Connection
Install Rust

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -(Mac Os)

download and run rustup-init.exe -(Windows)

Install target

rustup target add wasm32-unknown-unknown

Install Cargo

brew install cargo-c

Install Stella CLI

cargo install --locked stellar-cli --features opt

Goal for this Tutorial

Implementing a transfer_xlm function - to transfer native XLM token from a public address to another contract address or public address

Picture Representation of the transaction in Stellar Expert

Glossary

XLM - is the native cryptocurrency of the Stellar network. This is the token used to paying small transaction fees, creating new accounts. XLM can also be bought, sold, or traded like other cryptocurrencies.
Public Address/Key: This is like your email address in the Stellar world. It's a unique string of letters and numbers that identifies your account on the Stellar network. You can share this freely with others when you want to receive funds or interact with the network. It always starts with a 'G' and looks something like "GBYUHQVNEEOXYXJTONRDFRMBZYXGB3SXOITQ2WMDZ44DEAKYSBYL4JZF"
Secret Address/Key: This is like the password to your Stellar account. It's a private string that should never be shared with anyone. With this key, you can access and control your account, send funds, and sign transactions. It always starts with an 'S' and looks similar to the public key: "SBCVMMCBEDB64ZDTSFLBDBO6UIFRS4JQWHXQYP6ABLSOZXMZNXJB7OVU"
KeyPair: A keypair is simply the combination of your public key and secret key. It's like having both your email address and password together. When you create a Stellar account, you're essentially generating a keypair. The public part of this pair becomes your account address, while the secret part is used to control the account.
Stellar Smart contract: A Stellar smart contract is like a set of rules or instructions that automatically do things on the Stellar network. In our case, we are going to be creating the "transfer_xlm" function within our smart contract
Soroban: Stellar's smart contract system is called "Soroban".

Now back to the good Stuff, the below picture shows the goal of this tutorial, but with the above knowledge this should get you excited for what is to come

Programming Language used

Rust

We are using Rust for the below reasons, Stellar chose Rust because:

It's very secure, which is important when dealing with financial transactions
It's fast, so contracts can run efficiently
It helps prevent common coding mistakes

STEPS to follow

Open VS Code, and create a new Folder, Make sure the name of the folder is separated by "_" or "-". Never use space in a folder name
Open Terminal, the terminal will open your root directory that is all commands you write here will be applied to this folder.
We are going to run the command below on the terminal to create a react-next app project

npx create-soroban-dapp@latest

This will create our project and install the neccessary dependencies

You will be asked some questions below

What will be the name of your project? your-project-name
Please select your favourite package manager: choose npm
Do you want us to install dependencies for you? Y
Should we continue and set up the dapp? Y

cd your-project-name
npm run dev

Now the installations is complete, "npm run dev" will start a local server for your dApp. Copy the link (localhost:3000) and paste on your Browser preferably Chrome

We will be focusing on the "contracts" folder in your project.

Navigate to contracts, then greetings folder, then src, then lib.rs (this is where we are to implement our functions). So the greetings folder is the smart contract. We can choose to rename the greetings folder, but i will leave it as it is.
Remove the default functions and replace with the transfer_xlm() function below
We will implement the "transfer_xlm()" function

I will explain the concepts here:

This imports the necessary dependencies, the "#![no_std]" removes the big library tools from the project making the project light and small

The "use soroban_sdk" is using specific tools from the Soroban toolkit." Each item in the curly braces is a tool we might need for our smart contract.

#![no_std]
use soroban_sdk::{contract, contractimpl, contracttype, Address, Env, String, Symbol, Vec};
use soroban_sdk::token::TokenClient;

DataKey are like special containers for information that you want to use in your smart contract. For example, we are going to store the result of our xlm token into the Datakey "Token".

#[derive(Clone)]
#[contracttype]
pub enum DataKey {
    Token
}

In the transfer_xlm function, "env", "from", "to", and "amount" are parameters. The "env" typically represents the environment in which Soroban smart contracts execute.
from.require_auth() - it's used to ensure that certain operations within a smart contract are only performed by authorized parties. it does this by requesting for the secret key to authenticate the transaction.
This holds and store the xlm contract address, the contract address here is the XLM testnet address. Then, we save this into the DataKey Token.


assert!(amount > 0, "amount must be positive");
let xlm_address_str = String::from_str(&env,
       "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC",
        );
let xlm_address = Address::from_string(&xlm_address_str);
env.storage().persistent().set(&DataKey::Token, &xlm_address);

TokenClient then creates the token and using the .transfer() function it transfers the token from the "from" address to the "to" address, the "amount" of tokens. Now XLM smallest unit is stroops which is 10^7 so to get 1XLM token, 1 XLM (Lumen) = 10,000,000 stroops.

let token = TokenClient::new(&env, &xlm_address);
token.transfer(&from, &to, &amount);
true

Finally, we send true representing a successful transfer.
Navigate to greeting folder, Run the command in the terminal, to build the contract

cd my-project-name
cd contracts
cd greeting
stellar contract build

Go back to root directory using "cd ./" multiple times

npm i @stellar/stellar-sdk

Configure the CLI for Testnet, for Windows remove the "\" and replace with "`"

stellar network add \ --global testnet \ --rpc-url https://soroban-testnet.stellar.org:443 \ --network-passphrase "Test SDF Network ; September 2015"

Configure an Identity, thats the "token-admin" will be used as sourceAccount

stellar keys generate --global token-admin --network testnet stellar keys address token-admin - (To see the Public key of token- admin)

By default "stellar keys generate" will fund our token-admin with 10,000XLM by the Friendbot
Navigate back into "greeting" folder using "cd", Run the command to install

stellar contract upload \ --network testnet \ --source token-admin \ --wasm target/wasm32-unknown-unknown/release/greeting.wasm

A WASM HASH (WebAssembly) will be generated here, input it into the next step in the "(--wasm-hash)

Now we are going to deploy the smart contract using this command.

stellar contract deploy \ --wasm-hash f02ce4b958e5e5d426e40787486d6c46fdc4826c874b93e307dac74f1191f1db \ --source token-admin \ --network testnet

At this point our smart contract is deployed, you should now see the contract address. For example "CA4KNSGXAI47V7AQLIOAXZ7FX4V4HLS6QNYFGRNFZM2UEOJTYFNM6OKC"
Go on to Stella Expert, at the top-right side of the screen, select Network: testnet and paste your contract address to view the deployed address

Now, you can see the transfer function in the contract by clicking "interface"

To interact with the deployed smart contract, run this command.

stellar contract invoke \ --network testnet --source token-admin \ --id CA4KNSGXAI47V7AQLIOAXZ7FX4V4HLS6QNYFGRNFZM2UEOJTYFNM6OKC \ -- \ transfer_xlm \ --from token-admin \ --to "CA4KNSGXAI47V7AQLIOAXZ7FX4V4HLS6QNYFGRNFZM2UEOJTYFNM6OKC" \ --amount "10000000000"

Here, we run the "transfer_xlm", we are transfering 1000XLM from the token-admin address to our deployed contract address. Its worthy to note that you can transfer from another public address not a must it should be from "token-admin".

View this post to understand in depth the various attribute used in the transfer_xlm() function: View Post here

At this point, you should get "true" showing a successful transfer of 1000XLM to your contract address. You can view the recent transaction at stellar expert.

I hope you learnt a lot.

GitHub link: Github Repo

Video Explanation

What I Created

My Submission is a walk through showing a complete beginner how to start from an empty folder to deploying a smart contract and interacting with it. This supports developers in showing them how to deploy their smart contracts quickly in one page instead of looking through different pages online to get this information. They can quickly hit the ground running with this tutorial.

Journey

I am particularly proud of participating in this challenge as it has helped me into understanding the basics of blockchain, cryptocurrency and decentralised applications. It is a wonderful experience but really tough when you have no experience, thats the major reason i created this tutorial to show beginner developers the easier way.

Most of my research came from Stellar documentation, Google and Stellar Discord channel.

DVILLA E-Commerce Project: A dApp that promotes healthy living

Chieloka Madubugwu — Thu, 15 Aug 2024 18:56:09 +0000

This is a submission for the Build Better on Stellar: Smart Contract Challenge : Build a dApp

What I Built
Demo
My Code
Video Explanation
Journey
Concepts Learned
Next Steps

What I Built

Dvilla Local Food Store project is a decentralised E-Commerce app where users can register an account and purchase organic foods and fruits, the app also rewards consistent users a little percentage to encourage people to stay on healthy foods and promote good living. The app leverages Stellar smart contracts to manage secure transactions, particularly in regions without credit card access, by placing assets in a vault during procurement and delivery. Payments are transferred only after safe delivery. Buyers are rest assured that payments are made or transferred to the local farms after their food items have been delivered safely to them. Its covers the Sustainability prompt and designed to fit into the category of a public goods application, where it incorporates features that contribute to real-world positive impacts. it promotes and sell products that are sustainably sourced from local farms.

Demo

The dApp is built on Next js for the frontend and Rust programming language for the backend and it incorporated the Stellar SDK for the Cli commands to interact with the blockchain and Soroban for the wallet

NOTE - To access the public url, make sure to install the Freighter wallet chrome extension. Currently, freighter wallet is unavailable for Android so download the Freighter chrome extension, create a wallet, and open the Public Url on Mac or Windows

Public Url: DVILLA E-commerce Project

My Code

The Github Repo: Github Repo

Video DEMO

Contract on Stella Expert

Stellar Expert : Transactions done on the Contract address

The other function i implemented is the "place_order" is implemented to pay or place a cart order, it transfer the amount from the user to the contract address, then saves the order and creates a tracker that calculates the user rewards

Rust function implementation for the place_order function

Then on the frontend to sign and submit the transaction, we first need to build the transaction

Journey

For my project, I designed and implemented a smart contract on the Stellar network to facilitate seamless transactions for a local food store. The motivation behind this project was to create a decentralized application (dApp) that supports local businesses by enabling them to accept payments in XLM, thereby promoting financial inclusion and sustainability.

One of the functions which i implemented and which made me understand a lot about the concept of blockchain is the "transfer_xlm()" function. This function was used to transfer token with in place_order function and process_user_reward function

Concepts Learned

sourceAccount (--source): This is the admin that invokes the contract to do a transaction. The admin should be generated with its keyPair that is both public Key and Secret key. Its only with the secret key that a transaction is signed. Meaning the admin signs thats transaction. 
id or contract_id (--id): This is the address of a contract after it has been deployed. The contract_id holds all the functions of that contract. So in the case, you want to transfer a token from an address to another address. The transaction must happen on a contract having “transfer” as one of its functions.   
Network (--network): This is the network on which the contracts were built or deployed on and where you will also be invoking the “transfer” transaction. This is either "testnet", "futurenet" or "mainnet".
transfer_xlm: This is the name of the function in my localfoodstore contract id/address.  
From (--from): This is still the admin address or sourceAccount. For the transfer transaction, the admin must have a lot of XLM tokens to send to the address “to”. The address here must have been generated having its key pair (public key and secret key) and have been funded by the friendbot or another address.It’s worthy to note that if you dont have the secret key of the public address here, the transaction will fail. This can also be called Issuer address.
To (--to): This holds the address to which the tokens are sent to. This address can be a contract id/address or a personal public address. This can also be called recipient address.
Amount (--amount): this is the amount of tokens to be sent to the public or contract address. It can be the native XLM token or any non-native assest.

Here you can see the transfer of 1000XLM was successful to my contract address

Additional Prize Categories: Glorious Game and/or Super Sustainable

My Submission is largely under the Super Sustainable dApp category.

Next Steps

I hope to include feature to give the users the choice to donate their rewards to charity organisations
Also I will need to improve the UI

Reach me here for collaborations:
LinkedIn
Gmail
Whatsapp

DEV Community: Chieloka Madubugwu

Golden Circle - A app for the Elderly users

The Community

What I Built

Demo

Code

How I Built It

Product Expiry Tracker AI with KendoReact

Table of Contents

What I Built

Demo

App Screenshots

Video DEMO

KendoReact Experience

KendoReact Free Components Used

AIm to Impress

AI Integration Pictures

A Guide to Quickly Deploying and Interacting with Smart Contracts Using the Stellar CLI

Table Of Contents

Overview

Tools to have before coding

Goal for this Tutorial

Glossary

Programming Language used

STEPS to follow

Video Explanation

What I Created

Journey

DVILLA E-Commerce Project: A dApp that promotes healthy living

Table of Contents

What I Built

Demo

My Code

Video DEMO

Journey

Concepts Learned

Next Steps