Open source project plan

Hey Austin. I was inspired and thought of a new project. It is entirely open source and I gain nothing from this except get to show what I am working on in hopes to inspire other people to start a more charitable mindset. So I outline my full plan in this repo I am building. The repo is for a full stack application which anyone can use for free on their own. It is more of meant to just be run on docker on your home set up rather than actually be deployed. Why? Because it is free. Free always wins unless the expenditure is productive. Anyway. I recently overcame being homeless and would like to help other people in similar circumstances. I identified several items which upon acquisition enabled me upon my path towards recovering my life. The first item was simply a set of colored pencils. Other items included a basic phone, chromebook, laptop, macbook, deposit for rental to drive for Uber, deposit for apartment, car or any other item you can think of which is productive with the amount of value it expends. If you can accomplish the same goal or close enough to it with less then that is what I try to approach out of efficiency and optimization. Also along the way certain milestones were achieved regarding going from being completely on the streets with just what I could carry to having a stable life which now allows me to give back. My first item I am giving away are two sets of colored pencils with sharpeners and notebooks for two people. I plan on discovering the people to gift these items to through careful observation and getting to know the homeless people in the area. I don't care if I never see these things again, that is not the point, they can trade it for whatever and someone else will find use for it, but ideally I would continue to walk each week the same route and hopefully be able to follow up with the same people and see if they have made any progress. I want to do that and then hopefully if they produce something good I will buy it from them and display it in my apartment and sell it to people who come and visit, give 100% credit and cash to them. I am also good with SWE and would like to help mentor people that way, but first I am just doing this as a trial to see how it goes. I can build them a basic next.js site which can be hosted for free and I could help them create an online presence and market their art. They would get everything themself. This is not about profiting, but rather sharing how I have monetized and succeeded in the past, and where I have failed. My goal really is to form some new friends with people who I can help with their life given my experience weathering difficult times myself. But it is short term as I hope that people will continue to spread the good will to others and repeat my method until everyone has a productive use of their time which they can trade the work of their labor for capital and improve their life through further acquisition of technology allowing more and more valuable employment to be found and to catch up to the new economy. So my software idea is basically just a next.js frontend and django backend using sqlite for a basic app you can run in docker for easy replication and the idea for it is to create a way for a mentor to keep track, chart, and gamify their philanthropic efforts. Gamifying philanthropy. That is the application. I am not good at frontend so it won't be pretty, but it doesn't have to be because I will likely be the only user, but I am building it for everyone. That is the point of this post. To share this project. Because I am building it for everyone. All means not just Y'all but All Y'all. A full-stack application designed to support talent discovery, mentorship, skill development, monetization, and community-building. The platform empowers participants to grow their skills, document progress, sell their creations, and build a digital presence while connecting with mentors and peers. That is my description of it. I am developing it open source and just wanted to share my progress. I just started vibe coding it today and this is as far as I got before I ran out of free credits and I don't pay for it so I will have to wait till tomorrow to continue work on it. But what is more is I just ordered the first two sets of colored pencils notebooks and sharpeners. This should all be ready before my next walk. But honestly I really hurt myself on the last one and my body might not be ready so I may wait until next week to go downtown again but maybe I can find people closer to me as well. But this is meant to be created open source so that anyone else can use this software for free so that they can track what they are doing and what works and what does not when they try to help the homeless. Think of it like CRM but instead for homeless outreach instead of selling people something. The concept behind it is simple. Everyone has a skill they have sunk 10,000 hours into or they are working towards that or they have not started yet but that does not mean they never will or not have that capability so everyone is on the same level. But the people who have over 10,000 hours experience can mentor other people who do not have that amount of practice or have not begun working towards it. As this is geared towards helping the homeless the skills I focus on developing from mentor to mentee are those which will help them bring abundance to their lives through increasing the value of their labor and giving them a merit based system like AI hiring to give them the opportunities otherwise out of reach. So the software allows you to teach that skill to the mentees and track everything. You would have to create your own business models to do this. One is to recruit homeless SWE which there are a lot of in Austin actually. Then what you can do is collect the referral but I am not going to do that. Instead I am going to allow them to let someone else give them a referral such as another worker I have helped get an account rather than myself so that I end up not getting anything for this. This is meant to be a net zero profit venture on my part which is also why I only do things for free for it as much as possible. Everything else is just burnt money but that is what that money is meant to be for. I was raised to give 10% of your income to the church but I don't go to church anymore so instead I am giving it to my neighbors who are less fortunate than myself. It is my new hobby. I am hoping that I can develop this software more once my credits renew each day. So my skills are art and SWE so that is what I try to be a mentor for. I have experience working professionally doing both so I can help them even though I am not the most successful artist or SWE in the world in fact not that successful at all in comparison to most other artists and SWE that are worth anything. I recognize my own limitations, that being said I have had small wins and that is better than all the big loses I had along the way attempting to tinker something into existence.

Love this, Austin — this is beautiful work and exactly the sort of practical, humane tech I want to help you ship. I read everything you wrote and put together a focused, pragmatic plan + an opinionated starter scaffold you can copy/paste into a repo and run locally with Docker. I also included data models, a small Django REST API (DRF) sketch, a Next.js frontend layout, Docker compose, and a README you can drop into the repo. I kept the scope intentionally simple so this is easy to run on a home machine and iterate from. If you want, I can paste each file as ready-to-save content in follow-up messages (or generate more files). For now — everything below is self-contained and actionable. # What this app does (MVP) - Run locally in Docker (no cloud required). - Mentors can add outreach “contacts” (people), log gifts, lessons, tasks, and progress entries. - Tracks simple gamified metrics (streaks, points, badges). - Stores artifacts (image/url to artworks) and simple commerce flow (purchase from participant handled offline; record transaction). - Simple web UI (Next.js) to view dashboard, add entries, and visualize progress charts. - Lightweight: Django + DRF backend with SQLite, Next.js frontend, docker-compose to run both. --- # Repo layout (suggested) ``` homeless-mentor-crm/ ├─ backend/ │ ├─ Dockerfile │ ├─ manage.py │ ├─ requirements.txt │ ├─ project/ │ │ ├─ settings.py │ │ ├─ urls.py │ ├─ app/ │ │ ├─ models.py │ │ ├─ serializers.py │ │ ├─ views.py │ │ ├─ urls.py │ │ ├─ admin.py ├─ frontend/ │ ├─ Dockerfile │ ├─ package.json │ ├─ pages/ │ │ ├─ index.js │ │ ├─ dashboard.js │ │ ├─ contacts/[id].js │ ├─ components/ │ │ ├─ Navbar.js │ │ ├─ ContactCard.js ├─ docker-compose.yml ├─ README.md ``` --- # Key data model (Django ORM) Paste this into `backend/app/models.py`: ```python from django.db import models from django.contrib.auth.models import User import uuid class MentorProfile(models.Model): user = models.OneToOneField(User, on_delete=models.CASCADE) display_name = models.CharField(max_length=120, blank=True) class Contact(models.Model): # a person you meet/outreach to (keeps PII minimal; email/phone optional) id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False) created_by = models.ForeignKey(User, on_delete=models.CASCADE) display_name = models.CharField(max_length=200, blank=True) # nickname notes = models.TextField(blank=True) location_hint = models.CharField(max_length=200, blank=True) # e.g. "5th & Main" is_active = models.BooleanField(default=True) created_at = models.DateTimeField(auto_now_add=True) class Gift(models.Model): # items you give away (colored pencils, notebooks) contact = models.ForeignKey(Contact, on_delete=models.CASCADE, related_name="gifts") name = models.CharField(max_length=200) details = models.TextField(blank=True) given_at = models.DateTimeField(auto_now_add=True) value_estimate = models.DecimalField(max_digits=8, decimal_places=2, null=True, blank=True) class ProgressEntry(models.Model): contact = models.ForeignKey(Contact, on_delete=models.CASCADE, related_name="progress") created_by = models.ForeignKey(User, on_delete=models.SET_NULL, null=True) title = models.CharField(max_length=200) body = models.TextField(blank=True) date = models.DateTimeField(auto_now_add=True) points = models.IntegerField(default=0) # gamification points class Task(models.Model): contact = models.ForeignKey(Contact, on_delete=models.CASCADE, related_name="tasks") title = models.CharField(max_length=200) description = models.TextField(blank=True) due_date = models.DateField(null=True, blank=True) is_complete = models.BooleanField(default=False) created_at = models.DateTimeField(auto_now_add=True) class Artifact(models.Model): # artworks, items, URLs to images contact = models.ForeignKey(Contact, on_delete=models.CASCADE, related_name="artifacts") title = models.CharField(max_length=200) description = models.TextField(blank=True) image_url = models.URLField(blank=True) created_at = models.DateTimeField(auto_now_add=True) class Transaction(models.Model): # record of buying from participant artifact = models.ForeignKey(Artifact, on_delete=models.SET_NULL, null=True, blank=True) contact = models.ForeignKey(Contact, on_delete=models.SET_NULL, null=True) amount = models.DecimalField(max_digits=8, decimal_places=2) note = models.TextField(blank=True) created_at = models.DateTimeField(auto_now_add=True) ``` --- # API: serializers and views (DRF) `backend/app/serializers.py` (DRF): ```python from rest_framework import serializers from .models import Contact, Gift, ProgressEntry, Task, Artifact, Transaction class ContactSerializer(serializers.ModelSerializer): class Meta: model = Contact fields = '__all__' read_only_fields = ('id','created_by','created_at') class GiftSerializer(serializers.ModelSerializer): class Meta: model = Gift fields = '__all__' read_only_fields = ('given_at',) class ProgressEntrySerializer(serializers.ModelSerializer): class Meta: model = ProgressEntry fields = '__all__' read_only_fields = ('date',) class TaskSerializer(serializers.ModelSerializer): class Meta: model = Task fields = '__all__' class ArtifactSerializer(serializers.ModelSerializer): class Meta: model = Artifact fields = '__all__' class TransactionSerializer(serializers.ModelSerializer): class Meta: model = Transaction fields = '__all__' ``` `backend/app/views.py` (DRF viewsets): ```python from rest_framework import viewsets, permissions from .models import Contact, Gift, ProgressEntry, Task, Artifact, Transaction from .serializers import ( ContactSerializer, GiftSerializer, ProgressEntrySerializer, TaskSerializer, ArtifactSerializer, TransactionSerializer ) class IsOwnerOrReadOnly(permissions.BasePermission): def has_object_permission(self, request, view, obj): return obj.created_by == request.user class ContactViewSet(viewsets.ModelViewSet): queryset = Contact.objects.all() serializer_class = ContactSerializer def perform_create(self, serializer): serializer.save(created_by=self.request.user) def get_queryset(self): return Contact.objects.filter(created_by=self.request.user) # similarly for other viewsets class GiftViewSet(viewsets.ModelViewSet): queryset = Gift.objects.all() serializer_class = GiftSerializer def get_queryset(self): return Gift.objects.filter(contact__created_by=self.request.user) class ProgressEntryViewSet(viewsets.ModelViewSet): queryset = ProgressEntry.objects.all() serializer_class = ProgressEntrySerializer def get_queryset(self): return ProgressEntry.objects.filter(contact__created_by=self.request.user) class TaskViewSet(viewsets.ModelViewSet): queryset = Task.objects.all() serializer_class = TaskSerializer def get_queryset(self): return Task.objects.filter(contact__created_by=self.request.user) class ArtifactViewSet(viewsets.ModelViewSet): queryset = Artifact.objects.all() serializer_class = ArtifactSerializer def get_queryset(self): return Artifact.objects.filter(contact__created_by=self.request.user) class TransactionViewSet(viewsets.ModelViewSet): queryset = Transaction.objects.all() serializer_class = TransactionSerializer def get_queryset(self): return Transaction.objects.filter(contact__created_by=self.request.user) ``` `backend/project/urls.py` (include router): ```python from django.urls import path, include from rest_framework import routers from app.views import ContactViewSet, GiftViewSet, ProgressEntryViewSet, TaskViewSet, ArtifactViewSet, TransactionViewSet router = routers.DefaultRouter() router.register(r'contacts', ContactViewSet) router.register(r'gifts', GiftViewSet) router.register(r'progress', ProgressEntryViewSet) router.register(r'tasks', TaskViewSet) router.register(r'artifacts', ArtifactViewSet) router.register(r'transactions', TransactionViewSet) urlpatterns = [ path('api/', include(router.urls)), path('api-auth/', include('rest_framework.urls')), ] ``` --- # Gamification rules (simple, configurable) Store as JSON (e.g. `config/gamification.json`), so it’s easy to tweak: ```json { "points": { "given_gift": 10, "progress_entry": 5, "completed_task": 8, "artifact_uploaded": 6, "streak_day": 2 }, "badges": [ {"id": "starter-kit", "name": "Starter Kit", "rule": "first_gift_given"}, {"id": "artist", "name": "Artist", "rule": "3_artifacts_uploaded"}, {"id": "helper", "name": "Helper", "rule": "10_tasks_completed"} ], "levels": [ {"level": 1, "threshold": 0}, {"level": 2, "threshold": 50}, {"level": 3, "threshold": 150} ] } ``` Implement a small service function to award points when actions happen (e.g., in signals or after save). --- # Docker / local dev config `docker-compose.yml` (root): ```yaml version: '3.8' services: backend: build: ./backend command: sh -c "python manage.py migrate && python manage.py runserver 0.0.0.0:8000" volumes: - ./backend:/app ports: - "8000:8000" frontend: build: ./frontend volumes: - ./frontend:/app ports: - "3000:3000" environment: - NEXT_PUBLIC_API_BASE=http://localhost:8000/api ``` `backend/Dockerfile` (simple): ```dockerfile FROM python:3.11-slim WORKDIR /app COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY . . EXPOSE 8000 CMD ["sh", "-c", "python manage.py migrate && python manage.py runserver 0.0.0.0:8000"] ``` `backend/requirements.txt` minimal: ``` Django>=4.2 djangorestframework gunicorn psycopg2-binary ``` (we use sqlite, but keep psycopg2 in case someone swaps DB later) `frontend/Dockerfile`: ```dockerfile FROM node:18-alpine WORKDIR /app COPY package.json yarn.lock ./ RUN yarn install --frozen-lockfile COPY . . EXPOSE 3000 CMD ["yarn", "dev"] ``` --- # Next.js frontend sketch `frontend/pages/index.js` - a tiny landing page linking to dashboard: ```jsx export default function Home() { return ( <main style={{padding:20}}> <h1>Gamified Philanthropy — Mentor Dashboard</h1> <p>Open-source app to track outreach, gifts, art, and progress.</p> <a href="/dashboard">Go to Dashboard</a> </main> ) } ``` `frontend/pages/dashboard.js` - call the API and show summary (very minimal): ```jsx import {useEffect, useState} from 'react' export default function Dashboard() { const [contacts, setContacts] = useState([]) useEffect(() => { fetch(`${process.env.NEXT_PUBLIC_API_BASE}/contacts/`) .then(r=>r.json()) .then(setContacts) .catch(()=>setContacts([])) }, []) return ( <main style={{padding:20}}> <h1>Dashboard</h1> <p>Contacts: {contacts.length}</p> <ul> {contacts.map(c => ( <li key={c.id}><a href={`/contacts/${c.id}`}>{c.display_name || 'unnamed'}</a></li> ))} </ul> </main> ) } ``` A small `components/ContactCard.js` and `Navbar.js` would round things out. --- # Privacy, ethics & safety notes - Minimize PII: store only what’s essential (nickname, approximate location hint) and avoid storing exact government IDs, SSNs, or persistent phone numbers unless the person explicitly requests it. - Consent: get simple consent before adding someone’s info or uploading their art. - Offline transactions: record sales as transactions but handle money exchange offline — the app only logs it. - Data portability: let mentors export CSVs so data can be moved or handed off to community orgs. - Security: this is intended for local use. If anyone deploys it publicly, require authentication, HTTPS, and consider stricter PII rules. --- # Simple roadmap (MVP → v1) 1. MVP (this): contacts, gifts, tasks, progress entries, artifacts, transactions, simple Next.js UI, run in Docker. 2. v0.2: point awarding, badges, CSV export, user signup, invite flow for mentors. 3. v0.5: offline-first support (PWA), local image uploads, small admin UI to anonymize data for research. 4. v1: optional integration to host participant portfolios on static Next sites (mentor helps create a simple portfolio), multi-user sync if desired (opt-in with clear privacy). 5. Community: templates for “outreach workflows” (e.g., “art starter kit distribution” workflow) and seed data (common gift items, estimated values). --- # README.md (starter) Drop this as `README.md` root: ```md # Gamified Philanthropy — Mentor CRM (local) This is an open-source, local-first app to help mentors track outreach and skill-building with unhoused neighbors. Built with Django REST (backend) and Next.js (frontend) and designed to run locally in Docker. ## Goals - Simplicity: run on a home machine with Docker. - Privacy: minimize PII and prioritize consent. - Replicable: anyone should be able to run the stack and use it to help in their community. ## Quick start 1. Clone this repo 2. `docker-compose up --build` 3. Backend: http://localhost:8000/api/ 4. Frontend: http://localhost:3000/ ## Features (MVP) - Contacts: people you meet - Gifts: items given - Progress entries: notes, results - Tasks: todo for each contact - Artifacts: artworks & portfolio links - Transactions: record personal purchases from participants ## Contributing Open-source & public domain. Please keep PII handling in mind and prefer consented, anonymized data. ``` --- # Practical outreach & workflow ideas (what you already said — translated into software actions) - Weekly walk-in log: after a walk, open the app and create/annotate contacts, note gifts given, add tasks (e.g., “help sign up for library card”). - Starter-kit distribution: create a “Gift” record for each kit given, tag the gift `starter-kit`. - Follow-ups as tasks and progress: set a weekly task to check on a contact; award points for showing up, for creating an art piece, for attending a workshop. - Purchase & support: if a participant produces something you want to buy, record a Transaction and Artifact; credit them 100% in metadata. --- # Next steps I can do for you right now (pick any) - Generate the actual files for the backend & frontend (models, serializers, Dockerfiles, docker-compose, README) so you can `git init` and paste them. - Add a small seed script to create sample contacts and gifts for local testing. - Add frontend components for adding contacts/gifts/progress. - Add testing scripts and a small dev guide for contributors. Tell me which of the above you want me to produce first and I’ll paste the ready-to-save files into the chat so you can copy them straight into your repo. Or if you prefer, I can generate just the `backend/` or `frontend/` tree first. --- Austin — seriously, this is a gorgeous, human-centered project. If you want I’ll also help craft a short outreach pamphlet you can print and give people when you hand them supplies (simple one-page: “Your art matters — we can help you sell it online / get a phone / build a profile”). Want that next?

no I want you to rewrite what I wrote but make it sound like Dostovyevsky wrote it

Got it — here’s your whole story re-cast in the voice of Dostoevsky, with the same details but written in that brooding, searching, soul-heavy style he’s famous for: --- I have conceived a project, brothers, and it is not one for profit, nor will it yield me glory. It is a labor born of suffering and of memory, for only yesterday I walked the bitter road of homelessness, and now, emerging with trembling steps from the abyss, I desire to extend my hand to those still wandering in darkness. This endeavor, I confess, will be open to all. Free. For does not freedom itself triumph over every cost when expenditure serves no higher purpose? My design is for a modest full-stack application — a simple contrivance of code, running not upon the proud engines of commerce but in a humble Docker on a man’s own machine. It is not for enterprise, but for soul. Permit me, then, to recount what set me on this path. When I was at my lowest, when I possessed only what I could carry, a miracle appeared in the simplest of forms: a set of colored pencils. Not salvation, no, but a spark — small, radiant, absurd even. Later, a phone, a worn Chromebook, then at last a laptop, then a MacBook; each tool another rung on the ladder that lifted me inch by inch from despair. A deposit to drive for Uber, a deposit for a room, the key to a car, the lease of an apartment — thus the stations of my resurrection, each with its own measure of suffering, each with its own flicker of hope. Now, in the present moment, I walk again through the city streets, but with a different burden. In my hand I carry not only memory but two small gifts: two sets of colored pencils, with sharpeners and notebooks. I will place them, not as alms, but as seeds, into the hands of those who dwell on the pavement. Whether they are cherished, or traded away, or lost in the dust, matters little; for what counts is the encounter, the possibility, the repetition of the gesture. Perhaps I shall return each week along the same path and see if the seed has sprouted — if not in one, then in another. Should any fruit appear — a drawing, a page, a fragment of beauty — I will not merely admire it but purchase it, hang it in my dwelling, and display it to others. The author will receive all the credit, all the proceeds, all the recognition, for it is their creation, not mine. Thus art will not be left to languish on the street corner but will find its way into the world, speaking silently of dignity reborn. Yet I am not merely a buyer of pencils. I am also, in my humble fashion, a software engineer, and I am willing to guide others as a mentor, to build them a simple presence in the vast online bazaar, a Next.js site freely hosted, an open door into commerce. They shall hold the keys, not I. For what is this but the multiplication of one man’s small victories into the lives of others? Do not imagine this is a business venture. No, I seek neither wealth nor recompense, only fellowship — the forging of new bonds through shared labor and the passage of knowledge from one soul to another. And if I should fade from the stage, then let those who received continue the chain, passing the goodwill onward, until each finds himself lifted, until even the most destitute has in his possession the tools to transform his labor into sustenance, his creativity into bread. And thus the software. What is it, you ask? Nothing more than a ledger of kindness, a way for mentors to track their efforts, to chart their deeds, to observe patterns and results. A “CRM,” if you must use the mercantile word, yet turned upon its head: not a register of sales, but of mercies. And through a touch of play, through gamification, we dress philanthropy in the garments of joy — as though virtue were a game, and every gift, every lesson, every act of follow-up earned its own quiet reward. In the beginning it will be plain: a Django backend, an SQLite database, a Next.js front. Crude, awkward, no doubt ugly, for I am no artist of the front end. But beauty lies not in the polish but in the purpose, and perhaps others will take up the code and refine it until it serves many. Yes, this will be my tithe. Once I gave ten percent of my income to the church, as was the tradition of my fathers. Now I give it to my neighbors, those who wander still in the wilderness I have barely escaped. If my body weakens and I cannot walk downtown this week, then I will wait until next. If I must, I will search nearer to home. For I know the truth: that every man, however broken, harbors within himself the potential of ten thousand hours, the latent genius, the craftsman unborn. The role of the mentor is only to beckon forth what is already there. Therefore, let this project be a testimony: not of my strength, but of the fragile bridge that exists between despair and hope. For I was once cast aside, a stranger, and now, by some absurd grace, I can give. And giving — freely, uselessly, joyously — is life itself. --- Do you want me to make a shorter, more **project-focused Dostoevsky README version** (like it would appear on GitHub but still written in that voice), or keep it in this long, confessional narrative style?