DEV Community: iqbal singh

# Building a Community Rewards Platform with Flutter, Firebase and Weekly Rewards

iqbal singh — Sat, 06 Jun 2026 01:27:06 +0000

Over the past year, I've been building a project called WORK Network, a community-focused rewards platform designed around participation, progress tracking, and weekly rewards.

Like many side projects, it started as a simple idea and gradually evolved into something much larger.

One of the biggest lessons I learned is that building the app is often easier than building the systems around it.

The Technology Stack

The current platform is built using:

Flutter
Firebase Authentication
Cloud Firestore
Firebase Cloud Functions
Firebase Hosting

Flutter allowed a single codebase for Android and iOS, while Firebase significantly reduced backend complexity.

The Real Challenge: Fair Rewards

Creating screens and buttons was relatively straightforward.

The difficult part was designing a reward system that could remain fair as the platform grew.

Some of the questions I had to solve included:

How do weekly rewards work?
How can duplicate rewards be prevented?
How can progress be tracked accurately?
How can reward calculations remain consistent across devices?

As the project evolved, reward logic moved away from the client and into backend-controlled systems wherever possible.

Weekly Rewards System

One of the most interesting features is a weekly rewards model.

Instead of focusing only on daily activity, the platform tracks participation over time and allows users to qualify for weekly community rewards.

From a technical perspective this required:

Weekly snapshots
Reward qualification logic
Historical record keeping
Winner selection processes
Administrative controls

Building these systems taught me the importance of separating configuration, historical records, and live user data.

Firebase Lessons

Firebase has been incredibly productive, but there are some lessons I wish I knew earlier.

1. Design Data Structures Carefully

Changing Firestore structures later becomes expensive.

Spending more time on schema design early would have saved many migrations.

2. Keep the Backend as the Source of Truth

Any reward system should assume the client can be manipulated.

Critical reward validation should happen on the backend.

3. Plan for Growth

Queries that work for 100 users may not work for 10,000 users.

Indexes, aggregation strategies, and collection structures become increasingly important.

Building in Public

One unexpected benefit has been feedback from early users.

Several features that exist today came directly from community suggestions rather than my original roadmap.

The process reinforced an important lesson:

Users often identify the most valuable improvements long before developers do.

Final Thoughts

WORK Network is still evolving, and there are many features planned for the future.

The journey has been a reminder that successful applications are rarely built in a straight line. They evolve through experimentation, mistakes, user feedback, and continuous improvement.

For developers building their own projects, my advice is simple:

Start small.
Ship early.
Listen to users.
Keep improving.

Those four principles have helped shape every stage of this project so far.

Detecting if a User Is Actually Present on Mobile (Without Using Camera or Spying)

iqbal singh — Wed, 18 Feb 2026 01:02:12 +0000

One of the first problems we hit while building a reward-based mobile app was unexpected.

Not performance.
Not scaling.
Not payments.

Presence.

The Internet Counts Activity — Not Attention

Most systems assume something very simple:

If the app is open → the user is there.

But mobile behavior doesn’t work like that.

People open apps and:

put the phone on the table

switch to another device

mute videos

let content run in background

auto-play overnight

From a server perspective, this still looks like engagement.

From reality… the user left 20 minutes ago.

If rewards exist, this becomes a serious problem.

You are no longer rewarding a human.
You are rewarding idle electricity.

Why Traditional Signals Fail

At first glance, it sounds easy:
“Just detect interaction.”

But every simple signal breaks.

Screen ON → phone could be untouched
Video playing → not watched
App foreground → user not looking
Touch → automation possible

Even worse — modern mobile OS privacy rules remove many detection options.
No camera usage.
No intrusive monitoring.
No behavioral spying.

So the question becomes harder:

How do you verify presence without violating privacy?

Presence Is a Pattern, Not a Button

We realized attention isn’t a single action.

It’s a rhythm.

Real users behave inconsistently in very consistent ways.

They:

react inside natural timing windows

pause irregularly

interact slightly differently each time

get interrupted

return at human speeds

Automation behaves differently:

perfectly timed

repetitive

uninterrupted

statistically smooth

So instead of detecting one event…
we started validating sequences.

Not “did you tap?”
But “does your behavior look alive?”

The Shift in Thinking

We stopped asking:

Did the user interact?

and started asking:

Could this realistically be a person over time?

This transforms verification from an event problem into a probability problem.

Not certainty.
Confidence.

A presence score instead of a trigger.

Why This Matters

Reward systems fail when effort can be simulated.

If idle phones earn the same as active humans,
the system collapses into farming.

So before building any economy, we had to answer a simple question:

Can software recognize presence without surveillance?

We don’t fully know yet.

But we are experimenting with something we call:

Proof-of-Watch — measuring participation instead of playback.

Because attention might be the only scarce resource left online.

We’re testing these ideas in a project called WORK Network.

Feedback and Suggestion welcome

GooglePlay
https://play.google.com/store/apps/details?id=com.mobileweb3.workapp

AppStore
https://apps.apple.com/us/app/work-app/id6758291781

[Boost]

iqbal singh — Sat, 14 Feb 2026 14:52:20 +0000

We Built a System That Recognizes Human Time

iqbal singh ・ Feb 14

#mobile #flutter #firebase

We Built a System That Recognizes Human Time

iqbal singh — Sat, 14 Feb 2026 14:50:46 +0000

For years the internet has measured everything about us.

Clicks.
Views.
Location.
Scroll depth.

But one thing was never measured properly — human attention.

You can open a video and walk away.
You can mute an ad and leave the phone on the table.
Platforms still count it as engagement.

We wanted to solve a strange problem:

The internet knows what you touched —
but it never knew if you were actually there.

So we built a concept we call Proof-of-Watch.

A phone-based verification layer that confirms a user actually watched content before rewards are generated.

Not background farming.
Not bots.
Not auto play abuse.

Real presence → measurable time → rewardable activity.

This turns attention into something closer to a resource.

Bitcoin proved computing power had value.
Staking proved locked capital had value.

We are experimenting with a simpler question:

Does human time have value online?

Because right now billions of hours are spent on phones daily — but none of it belongs to the user.

We are not trying to replace social media.
We are trying to recognize the human behind the screen.

If time is life, then attention is digital life.

And digital life should be measurable.