Uber Eats and Dev Plan

I plan on doing uber eats and data annotation as my job now while I work on development work and hopefully some day get a development job, what actions should I start taking to ensure it all goes well

That's a solid plan: Uber Eats gives you flexible income, data annotation keeps you close to AI workflows, and development work is your long-term investment. Here’s a step-by-step plan to help you stay financially afloat, steadily grow, and transition into a developer role: --- ### 🛵 **1. Maximize Stability with Uber Eats** - **Set a weekly income goal**: Know your minimum expenses and make Uber Eats cover that consistently. - **Work high-efficiency hours**: Lunch/dinner rush, weekends, events, etc. Track which zones earn more. - **Track earnings + car expenses**: Use a spreadsheet or app (Gridwise, Everlance) to monitor net income. --- ### 🧠 **2. Structure Your Data Annotation Role for Growth** - **Position it as a learning experience**: - Focus on projects involving **LLMs, prompt engineering, model fine-tuning**, etc. - Take notes on patterns, edge cases, and ambiguous inputs—this is real-world data work. - **Sharpen your annotation tooling skills**: - Master open-source tools: Label Studio, Universal Data Tool, Prodigy. - If possible, write scripts for quality checking or analytics on annotations (Python, pandas, etc.). --- ### 🖥️ **3. Treat Dev Work as a Real Job Now** > The mindset shift: you already *are* a developer in training, not just “hoping” to become one someday. #### A. **Schedule Regular Dev Time** - Create a weekly schedule: 3–5 dev sessions, 1–2 hrs minimum, even if you're tired. - Start small, but **stay consistent**. Uber can adjust around it. #### B. **Work on 1-2 Portfolio Projects** - Choose projects that *align* with your long-term goals. Example ideas: - **LLM annotation tool** that takes JSONL and provides feedback via a local model. - A **React + Django** journaling app with AI insights from Ollama. - A **data quality dashboard** for annotation reviewers. Make it public and polished: - Push to GitHub. - Deploy to Netlify or Vercel (frontend), Railway or Render (backend). - Document it like a product. #### C. **Track what you learn** - Maintain a Notion, Markdown journal, or blog (Jekyll/Hugo) summarizing: - What you built. - What you struggled with. - What you plan to learn next. This becomes your **learning archive + blog content + interview prep**. --- ### 👥 **4. Build Career Momentum** #### A. **Networking** - Start posting weekly build logs on X/Twitter, LinkedIn, or Dev.to. - Engage with open-source repos you use (create issues, submit PRs). - Message people you admire or DM open-source contributors to ask questions or show gratitude. #### B. **Online Presence** - Keep [danielkliewer.com](https://danielkliewer.com) updated: - Showcase dev projects - Add a resume page - Embed blog posts from your learning archive - Resume: start tailoring it now for **“junior backend dev,” “AI tool developer,”** or **“prompt/data ops”** roles. #### C. **Job Scouting (1hr/week)** - Browse: - AI tool startups (on Y Combinator, Hacker News, Wellfound) - Contract annotation tech companies (Snorkel, Scale, Surge AI) - Open-source projects hiring contributors - Apply to 1–2 roles weekly starting *now*, even if you don’t feel “ready” --- ### 🛠️ **5. Keep Your Tools Tight** - Set up your local dev stack: - **Ollama** + **VSCode Copilot-like autocomplete** (Qwen, Codestral, etc.) - Docker + GitHub Actions for deployment - FastAPI, Django, React, SQLite/PostgreSQL --- ### 💡 Optional: Add a “Ritual” Something daily or weekly that reminds you: - You’re building a new life. - This is going to *work*, even if it’s hard now. Examples: - Journal a 3-line log every day on progress. - Write a weekly letter to your future self about what you’re learning. --- ### Summary Checklist | Focus Area | Actions | |------------|---------| | Income Stability | ✅ Optimize Uber hours and expenses | | Annotation Growth | ✅ Learn tools, document insights | | Dev Career Prep | ✅ Daily/weekly dev time + portfolio | | Public Work | ✅ Update GitHub, site, and resume | | Networking | ✅ Post, message, engage weekly | | Long-Term Jobs | ✅ Apply to 1-2 relevant jobs/week | --- Let me know if you'd like help setting up a system to track it all (e.g. Notion template, task manager, markdown planner). You’ve got the drive—this plan makes sure it turns into a real career.

explain “junior backend dev,” “AI tool developer,” or “prompt/data ops” roles.

Great question. These three titles overlap a lot but point toward different specialties within the AI/dev ecosystem. Here’s a breakdown of each and how they relate to what you're doing: --- ## 🧱 **1. Junior Backend Developer** ### 🔧 What it means: An entry-level developer who works mostly on the **backend** of web or mobile applications. Think APIs, databases, servers, and business logic. ### 💼 Typical Responsibilities: - Build and maintain REST or GraphQL APIs (e.g., using Django, FastAPI, Express). - Connect to databases (PostgreSQL, MongoDB, etc.) and write queries. - Handle authentication, file uploads, background jobs, etc. - Work with version control (Git) and deployment (Docker, CI/CD). ### 🧰 Common Tech Stack: - **Languages**: Python, JavaScript (Node.js), Go, etc. - **Frameworks**: Django, Flask, FastAPI - **Databases**: PostgreSQL, MySQL, SQLite - **DevOps**: Docker, GitHub Actions, Railway, Render ### ✅ Why it fits you: - You already work with FastAPI/Django. - You're deploying apps and working with JSON APIs. - Your annotation tools and journaling apps are already backend-heavy. --- ## 🧠 **2. AI Tool Developer** ### 🔧 What it means: A software developer who builds **tools that help train, evaluate, or interact with AI models**. Often works closely with ML engineers or researchers. ### 💼 Typical Responsibilities: - Build internal tools (like annotation UIs, model dashboards, dataset managers). - Integrate with LLMs via APIs (OpenAI, Ollama, HuggingFace). - Handle inputs/outputs for models (JSONL, embeddings, tokens, etc.). - Create prompt chaining or fine-tuning UIs. ### 🧰 Common Tech Stack: - **Frontend**: React, Vue, Svelte - **Backend**: FastAPI, Flask, Django - **LLM APIs**: OpenAI, Cohere, Ollama, HuggingFace Transformers - **Data formats**: JSONL, CSV, Parquet ### ✅ Why it fits you: - You're already building AI-enhanced journaling tools. - You’re annotating and exploring prompt strategies. - You’ve integrated Ollama and used models locally. --- ## ⚙️ **3. Prompt/Data Ops Engineer** > “Prompt/data ops” is a newer title, often used in startups or AI labs. ### 🔧 What it means: An engineer who focuses on preparing data and prompts to **train, evaluate, or align** AI models. Often a bridge between human annotators and LLM developers. ### 💼 Typical Responsibilities: - Write, test, and optimize prompts for LLMs. - Design annotation workflows (often in JSONL format). - Automate quality control and post-processing of prompts/responses. - Build small tools for data filtering, scoring, clustering, etc. ### 🧰 Common Tech Stack: - **Languages**: Python (pandas, scikit-learn), bash - **Annotation Tools**: Label Studio, Universal Data Tool - **LLMs**: OpenAI, Ollama, Claude, Mistral - **Storage**: SQLite, ChromaDB, HuggingFace Datasets ### ✅ Why it fits you: - You’ve done real-world annotation work. - You write prompt-based workflows and use feedback loops. - You’ve built tools for annotating, visualizing, and refining datasets. --- ## 🧭 Which should you pursue? | Goal | Role to Emphasize | |------|--------------------| | Want traditional dev job with job security? | **Junior Backend Developer** | | Want to stay in the AI space, closer to tools? | **AI Tool Developer** | | Want to get into labs, evals, or prompt engineering? | **Prompt/Data Ops** | You can aim to build a portfolio that **touches all three**, and apply based on the job title. Want help designing projects tailored to each role?

expalin how to Build and maintain REST or GraphQL APIs (e.g., using Django, FastAPI, Express).

Absolutely — let’s break it down into **what**, **why**, and **how** for building and maintaining REST or GraphQL APIs using frameworks like **Django**, **FastAPI**, or **Express**. --- ## 🧠 What Is an API? An **API (Application Programming Interface)** lets two systems talk to each other. - **REST API**: Uses standard HTTP methods (`GET`, `POST`, `PUT`, `DELETE`) to interact with resources (data) via URLs. - **GraphQL API**: Uses a single endpoint where the client specifies exactly what data it wants — more flexible but slightly more complex to set up. ### 📦 Example: If you have a journaling app: - `GET /entries/` → return all journal entries - `POST /entries/` → create a new journal entry - `GET /entries/42/` → return the entry with ID 42 - GraphQL: `query { entry(id: 42) { text, mood } }` --- ## ⚙️ How to Build a REST API We'll go over the steps using: - ✅ **FastAPI** (Python – fast, modern) - ✅ **Django REST Framework** (Python – full-featured) - ✅ **Express.js** (JavaScript – Node.js standard) --- ### 🐍 FastAPI Example #### ✅ Install: ```bash pip install fastapi uvicorn ``` #### ✅ Create main.py: ```python from fastapi import FastAPI from pydantic import BaseModel app = FastAPI() class Entry(BaseModel): title: str content: str entries = [] @app.get("/entries/") def get_entries(): return entries @app.post("/entries/") def create_entry(entry: Entry): entries.append(entry) return entry ``` #### ✅ Run it: ```bash uvicorn main:app --reload ``` - Visit: `http://127.0.0.1:8000/docs` (Swagger UI automatically generated!) --- ### 🐍 Django REST Framework Example #### ✅ Install: ```bash pip install django djangorestframework ``` #### ✅ Set up project: ```bash django-admin startproject myapi cd myapi python manage.py startapp journal ``` #### ✅ Define model (in `journal/models.py`): ```python from django.db import models class Entry(models.Model): title = models.CharField(max_length=100) content = models.TextField() ``` #### ✅ Add REST API views: ```python from rest_framework import viewsets from .models import Entry from .serializers import EntrySerializer class EntryViewSet(viewsets.ModelViewSet): queryset = Entry.objects.all() serializer_class = EntrySerializer ``` #### ✅ Wire up URLs with a router: ```python from rest_framework.routers import DefaultRouter from journal.views import EntryViewSet router = DefaultRouter() router.register(r'entries', EntryViewSet) urlpatterns = [ path('api/', include(router.urls)), ] ``` Now `/api/entries/` gives you REST endpoints. --- ### 🟨 Express.js (Node.js) Example #### ✅ Install: ```bash npm init -y npm install express ``` #### ✅ `index.js`: ```js const express = require('express'); const app = express(); app.use(express.json()); let entries = []; app.get('/entries', (req, res) => { res.json(entries); }); app.post('/entries', (req, res) => { const entry = req.body; entries.push(entry); res.status(201).json(entry); }); app.listen(3000, () => console.log('API running on http://localhost:3000')); ``` --- ## 🔄 How to Maintain an API Once built, **maintenance** involves: | Task | What It Involves | |------|-------------------| | 📜 Versioning | Add version numbers like `/api/v1/entries/` to avoid breaking old clients | | ✅ Validation | Use serializers or schemas to check incoming data (e.g., Pydantic, Django serializers) | | 🔐 Auth & Permissions | Add JWT, OAuth, or session-based auth to control access | | 🧪 Testing | Write tests (pytest, unittest, Jest) for each route | | 📈 Monitoring | Log usage and errors (e.g., Sentry, PostHog) | | 🚀 Deployment | Use Docker, Railway, Render, or a VPS to deploy your API | | 📚 Documentation | Auto-generate or write OpenAPI/Swagger or GraphQL docs | --- ## 🧰 Tools You’ll Want to Learn | Purpose | Tools | |--------|-------| | Routing / Endpoints | FastAPI, Django, Express | | Data Validation | Pydantic, Django Serializers, Joi (Node.js) | | Auth | OAuth2, JWT, sessions | | Database | SQLite, PostgreSQL, MongoDB | | Deployment | Docker, Render, Railway, DigitalOcean | | Docs | Swagger/OpenAPI, Postman, GraphQL Playground | --- Would you like me to help you build your own REST API step-by-step, maybe for your journaling or data annotation app?