Léonard Noth
ENFRDE
← projects

Dutine

A shared economy for chores nobody wants to do

A cross-platform app for assigning tasks and actually getting them done, through rewards and penalties.

Role
Sole author
Scope
Requirements · User research · Mobile app · Backend · Store release
Built with
Flutter, Dart, Firebase, Firestore, Cloud Functions, Node.js
Team
Solo
Timeline
May – July 2021 · graded 5.8
Outcome
Shipped on both the App Store and Google Play, peaked at around 150 monthly users, and was retired when I partnered with another app rather than keep maintaining it alone.

The problem

Every chore app assumes the hard part is tracking. It isn't. The person handing out the task already knows what needs doing, and the person receiving it already knows they haven't done it. What's missing is a reason to care by Thursday. My bachelor work started from that: the interesting problem in delegated tasks is sustained motivation, and motivation is the part nobody budgets for.

My role

Solo bachelor project at HEIA-FR, supervised by Pascal Bruegger. Requirements, survey, technology choices, both apps, the backend and the store submissions.

Read as
The essentials in two minutes

Impact

5.8 / 6
Grade
App Store + Google Play
Shipped to
~150 monthly users
Peak usage
102 pages
Report
May – July 2021, solo
Built in

The system design

  1. Agree the contract

    Two people, or one person alone, agree a shared economy: what the tasks are worth, what they cost to miss, and what the points can buy.

    • The giver defines the rewards and their point prices, and the punishments attached to missed tasks
    • Signup creates a relationship with yourself, so the app works solo without a special mode
  2. Track through the day

    Every screen reads live from the database, scoped to the one active relationship, so both sides always see the same state.

  3. Reckon at ten past midnight

    A scheduled job closes the day: tasks left incomplete trigger their punishment, completed ones pay out their points.

    • 00:10 local, not midnight. The survey asked how strict it should be and the answer was strict with a small margin
    • One scheduled endpoint per time zone, because the platform binds a schedule to a deployed function
  4. Spend what you earned

    Points buy the rewards the other person defined, which is the whole point: the incentive is negotiated, not imposed by the app.

  5. Look back

    A month grid per task, each day green, amber or red, so a pattern is visible rather than a single day's failure.

Platform services
  • Flutter

    One codebase for both stores, chosen on a weighted comparison against React Native and Xamarin, not on taste

  • Firebase Auth

    Identity, and the stream that the whole app's state hangs off

  • Firestore

    Eight collections, with security rules as the real access control: a document is reachable only by the two people on either end of it

  • Cloud Functions

    The nightly reckoning, as an endpoint per time zone

  • Cloud Scheduler

    The actual clock, firing each endpoint ten minutes after its own local midnight

Key decisions

Both roles, for everyone, by default

instead of · Pairs only, like both apps I compared against

57% of survey respondents expected to hold both roles, and most wanted to assign tasks to themselves, a use case I hadn't foreseen. Rather than bolt on a solo mode, signup creates a relationship with yourself. Seven people answering eight questions changed the product more than a month of thinking had.

Ten past midnight, not midnight

instead of · Strict midnight, or a lenient window up to the morning

The survey asked how strict the app should be and the answer was clear: strict, with a small margin for forgetting to tick something off. Midnight punishes the person who did the work and forgot to log it; 6 a.m. lets the deadline rot. Ten minutes is the smallest margin that respects both.

Twenty-seven copies of one function

instead of · One function taking the time zone as a parameter

The platform binds a schedule to a deployed function, so making the job fire at local midnight in twenty-seven places meant twenty-seven endpoints. It is indefensible on any code-quality metric and it was the right call against the deadline. I wrote that in the report rather than hiding it. It is the clearest example I have of a decision that is bad by one measure and correct by another.

Rewards from the literature, punishments from instinct

instead of · Presenting both halves as equally grounded

I could cite research for the reward mechanic. I could not for the punishment half, so I wrote “in our opinion” instead of dressing an instinct up as a finding. That asymmetry is still the most honest paragraph in the report.

In action

the app
the app
tasks and rewards
tasks and rewards

Dutine tracks and manages tasks assigned to people, and motivates them to finish on time through a system of rewards and punishments rather than reminders.

Shipped on both stores from a single Flutter codebase, with a Node backend on Firebase and Google Cloud.

What I learned

  • The interesting problem in a chore app is motivation, not tracking, and motivation is the part nobody budgets for.
  • A good survey question is one whose answer changes an implementation detail. “How strict should it be?” isn't a preference poll; it's how I chose the cron time.
  • Users invent your product for you. Self-assignment turned Dutine from a parenting tool into something anyone could use, and I hadn't thought of it.
  • Defend the ugly decision out loud. Duplicating one algorithm twenty-seven times looks terrible in a code review and was correct against the deadline. Writing down why is what makes it a decision rather than a mess.

What it doesn't do

  • The automated tests never got past the template. Shipping to both stores took the time a suite would have needed, and the 102 pages of the report went where the format rewarded depth: into the analysis. On a two-month solo project I'd make the same call today.
  • The two task forms are largely parallel copies of each other. That's the one piece I'd budget differently now: factor the shared form out early, before the deadline locks the duplication in.
  • It's no longer running: I shut it down and moved the users to another app rather than maintain it alone.