Find Python Projects with Vollna

We are working on a variety of SaaS tools and step 1 is to understand the following:
1. APIs - what they can support - what data we can push and potentially pull if possible - this includes things like Slack, Google Suite, etc
2. The complexity of creating certain key functionality from scratch using AI to code.

This requires problem solving and research. I will provide guidance on the needs - but what we really need is someone that can take the objective and come back with the ideal solutions.

I need a Google Agent built with the official development kit that can act as a conversational property finder focused exclusively on commercial listings. When a user asks “Show me offices in downtown Atlanta under 10 k sq ft” (or any similar query), the agent should probe for missing details, pull matching options from my data feed or an interim mock dataset, and return the results in a clear, structured format.

The flow must feel natural on both voice and text surfaces of Google Assistant. Core intents include location, budget, square footage, and property subtype; rich responses such as cards or carousels are preferred when the device allows. I’m aiming to have the agent deployed, tested, and ready for real-data integration within one month, so clean, well-documented code is essential for hand-off.

Deliverables:
• Dialog model and fulfillment code (Node.js or Python) fully runnable in my GCP project
• Connection to a sample or live commercial-property API with graceful fallback messaging
• Brief setup guide and video walkthrough showing the agent in action on Google Assistant simulator

If you have solid experience with Google Assistant SDK / Actions Builder and can turn this around quickly, I’d love to see what you can do.

Skills: JavaScript, Python, Software Architecture, Google App Engine, Google Cloud Platform, Chatbot, API Development, Natural Language Processing, Conversational AI

watch this videohttps://www.youtube.com/watch?v=3BaH7-3GQZk and other videos on my channel to see how i need my videos

I want to replace my current, mostly manual workflow with an automated pipeline that turns raw screen-captures and voice-overs into polished tutorial videos aimed squarely at beginners. The goal is simple: once I drop new assets into a folder (or push them to a cloud location) the system should assemble the sequence, add branded intro/outro, insert captions, normalise audio and export the final MP4 without further input from me.

You’re welcome to build this in the toolset you know best—Python with ffmpeg, Adobe Premiere Pro scripting, After Effects templates, or another proven solution—as long as the end result is repeatable and easy to operate on my Windows PC.

Please outline:
• the technologies you plan to use
• how a typical “one-click” run will work
• sample output or a quick demo if you have one

Once I can trigger the workflow, watch it finish and receive a ready-to-publish beginner-friendly tutorial video, the project will be considered complete.

Skills: Python, Video Services, After Effects, Video Production, Video Editing, Adobe Premiere Pro, Scripting, Audio Processing, Video Processing, Automation

**Job Title: HRIS Integration Architect**

**Reports To:** CEO

---

**Role Summary**

We are seeking an experienced **HRIS Integration Architect** to design, build, and scale a high-performance HR technology integration layer across HRIS, Payroll, ATS, Benefits, and Performance Management systems. This role will own API strategy and integration execution leveraging a unified API platform such as **Kombo** along with other open and free API technologies where applicable. The architect will ensure consistent, automated, secure data flows that support our growing suite of HR and Talent products.

---

**Key Responsibilities**

**Integration Architecture & Strategy**

* Architect and implement an enterprise-grade HR integration layer that unifies HRIS, ATS, payroll, benefits, and performance management systems.
* Evaluate, select, and standardize tools such as unified APIs (e.g., Kombo), internal microservices, SCIM/OIDC provisioning, and open-source integration frameworks.
* Define data mapping standards across employee lifecycle fields including performance reviews, goals, competencies, feedback loops, and organizational objectives.

**API Integration Implementation**

* Build integration connectors into major HRIS vendors using unified APIs like **Kombo’s HRIS API**, extending schema usage to include performance management endpoints (review cycles, goals, objectives, ratings, feedback).
* Develop custom connectors to performance management platforms when unified APIs do not support native coverage.
* Implement bidirectional sync workflows for employee profiles, organizational structures, 1:1s, review cycles, engagement data, goals, and OKRs.

**Performance Management Technology Integration**

* Own the integration roadmap for **performance and talent management systems**, including:

* Performance reviews
* Goal/OKR management
* Continuous feedback
* Competency frameworks
* Manager check-ins
* Calibration workflows
* Employee engagement and sentiment data
* Design standardized schemas and normalization layers supporting platforms such as **Lattice, Leapsome, 15Five, CultureAmp, Betterworks**, and other providers with open or semi-open APIs.
* Ensure performance management data flows integrate seamlessly into HRIS, ATS, and analytics dashboards.
* Build secure data pipelines that support sensitive performance-related data, maintaining rigorous governance and access controls.

**Platform & API Management**

* Establish API governance strategies covering performance management assets (goals, OKRs, review cycles).
* Implement distributed systems patterns for real-time performance data (streaming updates, eventing, webhook ingestion).
* Collaborate with DevOps to maintain observability and diagnostics for performance management sync jobs.

**Security and Compliance**

* Enforce privacy and compliance controls for sensitive performance data, including encryption, access controls, and SOC 2/GDPR alignment.
* Implement secure authentication and provisioning flows across systems using OAuth2, OIDC, and SCIM 2.0.

**Cross-Functional Leadership**

* Partner with People Ops, Product, and Customer Success to build integrations that support performance review cycles, engagement programs, and org-level reporting.
* Guide engineering teams on data modeling and scaling strategies for performance-related datasets.

**Documentation & Support**

* Document schemas, performance management data flows, integration setup guides, and troubleshooting patterns.
* Support customer onboarding and technical escalations involving HRIS, ATS, and performance management integrations.

**Qualifications**

**Technical Skills**

* 7+ years in software engineering, with deep expertise in enterprise integrations and API architecture.
* Experience integrating HRIS and ATS systems using unified APIs (Kombo, Merge, Apideck).
* Hands-on experience integrating **performance management platforms** (Lattice, Leapsome, 15Five, Betterworks, CultureAmp, Workday Performance & Talent, SuccessFactors PM/GM).
* Strong understanding of REST APIs, SCIM 2.0 provisioning, OAuth 2.0/OIDC, webhooks, and event-driven architecture.
* Proficiency with backend languages (Node.js, Python, Go, Java).

**Preferred Experience**

* Prior experience architecting performance management, OKR, or talent development data models.
* Familiarity with HR analytics and KPI frameworks for performance measurement.
* Experience with identity providers (Okta, Azure AD) and SCIM user lifecycle automation.

---

**Tools, Platforms & Technologies**

**Unified HR APIs**

**Kombo** — HRIS/ATS/Payroll/Time Off/Org structure unified API.
* **Merge HRIS API** — Broader HRIS connectors, including performance endpoints where available.
* **Apideck HRIS API** — Unified HR data access with OAuth management.

**Performance Management Technologies (Common APIs or Integrations)**

* **Lattice API**
* **Leapsome API**
* **15Five API**
* **CultureAmp API**
* **Betterworks/OKR API**
* **Workday Talent/Performance Management**
* **SAP SuccessFactors PM/GM**

**Open-Source / Free Integration Tools**

* **Postman** — API development and testing.
* **OpenAPI/Swagger** — Schema management and API documentation.
* **Apache Kafka / Redpanda** — Event streaming for real-time performance data.
* **Temporal / Airflow** — Workflow orchestration for review cycles.
* **OpenSearch / ELK Stack** — Logging and observability.

---
**Why This Role Matters**

Performance management data is one of the most sensitive, complex, and strategically meaningful components of HR technology. The HRIS Integration Architect ensures our platform delivers unified, real-time performance insights by integrating people data, goals, feedback, and review cycles from multiple systems into a single enterprise-grade experience.

This role is foundational to scaling our talent intelligence, analytics, and workforce capabilities.

I’m looking to set up a workflow that takes a raw topic idea and turns it into a finished YouTube video without manual intervention. The focus is on automation inside the editing stage, but I actually need the whole pipeline covered—from ideation right through to upload-ready MP4.

Here’s what I want the system to handle:

• Script writing based on a supplied keyword or brief
• AI voice-over generation that sounds natural and matches the script timing
• Visual content creation (stock clips, motion graphics, screenshots, or B-roll as needed)
• Automatic cutting, trimming, transitions, and text overlays so the final product is polished and engaging

My end goal is a repeatable, “videos-from-A-to-Z” solution: I feed a topic at one end and receive a fully edited video at the other, ready for me to hit “Publish.” If you have experience chaining together tools like Python, FFmpeg, Adobe Premiere Pro scripting, After Effects expressions, or newer no-code AI platforms (e.g., Pictory, Descript, or Runway), let’s talk about how you’d architect and deliver this. I’m open to whichever toolkit you prefer as long as the result is reliable and easy to scale.

Skills: Video Services, Animation, After Effects, Video Editing, Adobe Premiere Pro, AI (Artificial Intelligence) HW/SW, Automation

We are screening for a backend engineer who uses n8n as an orchestration tool, not as a no-code crutch.

This is not a no-code role.
You must be comfortable writing Python or JavaScript, working with APIs, and debugging real production issues.

We are intentionally not sharing project details yet. Selected candidates will move to a paid technical screening task.

Hard Requirements (Must Have)
Strong backend fundamentalsAbility to write Python or JavaScript

Experience with:
REST APIs
Webhooks
JSON payloads
Auth headers & error handling
Hands-on experience using n8n in real workflows

Comfortable deploying/debugging on a VPS (Docker knowledge is a plus)

If you only build drag-and-drop automations without coding, this role is not a fit.

Nice to Have
Twilio (SMS or Voice)
FastAPI or similar
Prior experience replacing Zapier/Make with n8n
Experience with production automations (not just demos)

Initial Screening (Answer ALL)
Which language do you primarily code in? (Python / JS / Other)

Have you used custom code nodes or external scripts with n8n? (Yes/No — explain briefly)

Describe a real bug you debugged involving APIs or webhooks.

Are you comfortable deploying and troubleshooting on a VPS? (Yes/No)

Next Step
Short-listed candidates will receive a paid technical screening task (fixed fee).
If the screening passes, we move immediately to a larger fixed-fee engagement.

Engagement Style:
Fixed-fee milestones only
Clear scope
Fast decisions
No long interviews

I’m building an AI-driven assistant to streamline my real-estate workflow and I need it written entirely in Python. The assistant has three core jobs: (1) pull fresh listings, structure them, and publish them to my site; (2) chat in real time with prospects, handling follow-ups automatically; and (3) generate concise market snapshots that I can share with clients or use internally.

Data will arrive from three places—online property databases, local agency feeds, and my own CSV / manual inputs—so the code must ingest APIs and scrape when necessary, normalise everything in a single store (PostgreSQL or a lightweight alternative), and keep the dataset updated on a daily schedule.

On the front end, I want a web-based chatbot that taps into the same knowledge base. It should greet visitors, answer questions about available properties, schedule showings, and note follow-up tasks in a simple CRM table. FastAPI, Flask or Django Channels are all fine as long as conversations feel immediate and the code remains readable.

Please structure the project so I can:

• run a single setup script and have the full environment (virtualenv, dependencies) ready;
• drop new data sources in via config files rather than hard-coding;
• review well-commented Python modules for scraping, NLP (spaCy / OpenAI, whichever fits best), ranking logic, and report generation;
• deploy the chatbot UI to my existing VPS with minimal fuss.

Hand-off items will include the complete repo, a short loom/video walkthrough, and clear instructions for scheduling the sync jobs on Linux cron.

If you’ve connected property APIs before or built chatbots that actually convert, your experience will shine here.

Skills: Python, Web Scraping, Django, Software Architecture, Web Development, Flask, Chatbot, FastAPI

I need a tool to batch process 500+ auction lot photos at once.

THE TASK:
For each image:
1. Extract/detect lot number (or mark as "NOT FOUND")
2. Identify high-value items ($50+ retail value)
3. Generate SEO-optimized title (80 chars) and description (2-4 paragraphs)
4. Export results to CSV

TECHNICAL APPROACH:
You choose the best tech stack, AI tools, and implementation.
I don't care how you build it - just that it works and is user-friendly.

REQUIREMENTS:
- Batch upload interface (accept 500+ images at once)
- Process images and return structured data
- Export to CSV ready for our auction platform
- Handle errors gracefully
- Include progress tracking

PHASES:
1. MVP: Single image → lot number + title + description + CSV export
2. Batch: Handle 500+ images, progress tracking
3. Polish: Documentation, testing, deployment

WHAT I PROVIDE:
- Sample pallet photos
- Example prompts (showing what good output looks like)
- Clear success criteria
- Feedback during development

HOW TO APPLY:
1. Propose your approach (what tools/tech you'll use)
2. Estimated timeline for each phase
3. Any clarifying questions
4. Portfolio link (batch processing, automation, or relevant projects)

ABOUT THE BUSINESS:
Auction house processing 1,000+ lots weekly. Each lot has 5 to 70 photos.
I'm thinking about using Google Sheets + Make.com + Claude but not complete at this time.

This will be a production system used by my team to speed up cataloging
and improve auction descriptions.

START: ASAP
CONTACT: Todd

We are seeking a skilled developer to create a comprehensive system for tracking public betting data across various sports. The ideal candidate will have experience with data collection, analysis, and visualization. This project requires a strong understanding of sports analytics and the ability to build a user-friendly interface for easy data access. If you have a passion for sports and data-driven solutions, we'd love to hear from you!

**N8N / Supabase / Voice AI Developer for Business Automation Platform**

We're building a comprehensive AI-powered Customer Intelligence Platform for a multi-location service business and need an experienced automation developer to assist with ongoing development and troubleshooting.

**Project Overview:**
Custom automation system integrating call tracking, voice AI assistants, customer behavior profiling, and workflow automation across multiple business units.

**Required Experience:**

- N8N workflow development and debugging
- Supabase (database design, functions, API integration)
- Retell AI voice platform
- GoTo Connect API (call tracking, SMS monitoring, webhooks)
- Claude API / Anthropic
- REST API integration and webhook handling
- Microsoft Power Automate
- SharePoint / Microsoft 365

**Nice to Have:**

- Experience with automotive or service industry
- ElevenLabs or similar voice synthesis platforms

**Scope:**
Ongoing part-time assistance with workflow development, API troubleshooting, database optimization, and implementing new features. Must be comfortable working from existing documentation and picking up mid-project.

**To Apply:**
Share specific examples of N8N workflows and Supabase projects you've built. Describe your experience with voice AI platforms and API integrations.

Budget: Hourly rate, ongoing engagement
Availability: Flexible, responsive communication preferred

**Hiring: Talented College Student Developer/Marketer – Build a Lead-Generating Social Platform for My Plumbing Company

Chicago-based plumbing company (serving the greater area) looking for a sharp, motivated college student to build a custom online community/social network designed to drive local plumbing leads straight to us. This is a paid freelance/project gig – perfect for building your portfolio and earning real money while in school!

**Project Overview:**
- Create a simple, user-friendly web-based social platform where homeowners can post plumbing issues, share tips, and connect with pros.
- Focus on lead generation: Forms, messaging, and integrations to capture inquiries for emergency repairs, installations, etc.
- Goal: Drive organic traffic and high-quality local leads to our plumbing business.

**Key Skills We're Looking For (the more you have, the better!):**
- Programming/web development (HTML/CSS/JavaScript, React, Node.js, Python, PHP – any full-stack experience)
- Database basics (MongoDB, MySQL, Firebase)
- Bonus: SEO expertise (on-page optimization, keyword research, Google Analytics setup)
- Extra bonus: Social media marketing, content creation, or growth hacking skills
- Familiarity with tools like GitHub, Figma, Bubble/Adalo (no-code options welcome if you can customize)

**What You'll Get:**
- $1,500–$4,000 total project pay (based on experience/scope – paid in milestones)
- Flexible part-time schedule around your classes
- Real-world project for your resume/portfolio
- Potential for ongoing work (maintenance, marketing campaigns)
- Mentorship and great references

**Requirements:**
- Current college student (CS, IT, marketing, or related major preferred)
- Chicago area ideal (for occasional meetups) but remote OK if you're reliable
- Able to show past projects (GitHub, personal site, class work – anything!)
- Reliable communication (Slack/Discord/email)

If you're a hustling student who loves building cool stuff that actually makes money for a business, this is for you!

**To Apply:**
Reply with:
- Your name, school, and year
- Quick summary of your skills/experience
- Links to GitHub, portfolio, or past projects
- Your availability and rate expectations

Subject line: "College Dev Application – Plumbing Social Platform"

Let's build something awesome and fill my schedule with plumbing jobs!
Email: [your email here] or message me directly. Looking to start ASAP!

FlowPro Plumbing
Jayson Levine
773-780-4200

Skills: PHP, JavaScript, Website Design, SEO, CSS, MySQL, HTML, Social Media Marketing, Web Development, Database Management

The goal is to extract every publicly available record behind the “Corporation Search / By FEI Number” section at https://search.sunbiz.org/Inquiry/CorporationSearch/ByFeiNumber and leave me with a clean, well-structured CSV.
• Coverage must be complete—active,(ONLY ACTIVE) inactive, domestic, foreign, all FEI ranges—so expect millions of rows.
• The final CSV (or split CSVs) should include every field shown on the detail pages: FEI/EIN, document number, entity name, status, address block, filing dates, last event, registered agent data, and any other metadata that appears. Consistent headers, no duplicate rows, no embedded line breaks or HTML entities.
• A reproducible solution is essential. Please hand over the scraper or ETL script (Python, Node, or similar), a brief README, and the compressed CSV output. I need to be able to re-run the process later without tweaking code.
• Respect site limits and stay within legal and ethical guidelines for public data collection. If you choose distributed requests, add throttling to avoid being blocked.
• Highlight prior experience with large-scale web scraping, data normalization, and handling multi-million-row exports; that specific background will weigh heavily in my selection.

Deliverables
1. Complete CSV dataset (zipped if needed)
2. Source code & environment notes
3. Short README outlining execution steps and expected runtime

Acceptance criteria: running the script locally reproduces the same row count and identical column layout as the delivered CSV.

Skills: Python, Data Processing, Web Scraping, Data Mining, Database Programming, Data Extraction, ETL, Data Management

# Full-Time MLOps, or Data Scientist (Work Hours: 9AM-5PM US Central Time)

## Work Condition
* You will be on a Google Meet video call for the entire work hours from 9:00 AM – 5:00 PM US Central Time (Monday to Friday)
**Please don't apply if this does not suit you.**


## Required Skills
* College level mathematics: calculus, integrals, linear algebra, etc.
* Data science libraries: scikit-learn, PyTorch, TensorFlow, etc.
* Familiar with machine learning models: linear regression, logistic regression, Support vectors, KMeans, PCA, etc.
* Familiar with deep learning models: Feed Forward Neural Nets, Recurrent Neural Nets, LSTM, Transformers, Diffusion models, etc.
* LangChain (Python)
* Linux (Ubuntu)
* Docker
* Google Colab
* VSCode
* Git
* Clouds (AWS, Azure)

## Optional Skills (We will teach you if you don't know these)
* Canva video editing
* CapCut video editing


## **Responsibilities**
* **Learn & understand** our **physics-inspired** data science courses thoroughly (the exact way they are) and
* explain/teach them to beginners
* answer questions about them
* Write content about them
* **Apply them to new data**
* Go through our existing data science projects and **implement/apply** what you learned in the **physics-inspired courses**.
* (You will be given full source code) **Create step-by-step guides** on how to start from an empty folder and end up with the complete provided source code. In other words, how to develop an entire data science project from scratch.
* Run machine learning & deep learning codes, debug them, fix dependency issues, etc.
* Create video tutorials about our **physics-inspired** ML courses.


## **Compensation**
* $1000 monthly salary

• Point me to your GitHub Repos where deep learning is used
• Will you be able to be personally present from 9 AM to 5 PM US Central Time?
• Are you fluent in all the listed requirements?
• Are you comfortable doing the tasks as listed in the job post?
• Can you edit the AI output extensively and make it a human version? This will be your main job. Please don't apply if you are going to just pass AI output. You will be fired soon.

Gigabite.ai is building global supply chain infrastructure for food distributors. www.gigabite.ai. We connect U.S. businesses with global suppliers using AI-powered matching and real-time freight/tariff calculations.

Small team, moving fast. You'll work directly with founder, 3rd-time, operate a $100M import company and our architect (owns core algorithms).

The Role
Architect handles quotation logic, freight/tariff, data pipelines. You own everything else:

Frontend: Distributor-facing experience — catalog, savings reports, quote flows. JavaScript, React/Vue. Heavy API integration.

Backend: Third-party integrations, internal tools, data import/export. Python. Work from existing patterns.

Quality: Enterprise customers find every broken flow. You catch problems first.

You see the full picture, make decisions, ship.

The ideal candidate has built data-heavy B2B tools — not marketing sites, Fluent in frontend (JavaScript, React/Vue, state management) and backend (Python, APIs)

Read existing code, understand patterns, extend without hand-holding

Detail-oriented. Notice when something's off before users complain.

Treat AI as a multiplier, not a crutch — you use Claude to move faster, but you own the output
Ask good questions, then run.

Plus if: Enterprise software experience. Logistics, supply chain, or distributor background.

We are a lean proprietary trading shop looking to incubate quantitative strategies with seed capital allocations.

We are not looking to "build a bot from scratch" based on our ideas. We are looking for Quant Developers or Data Scientists who have already developed and backtested a robust strategy but lack the balance sheet to scale it.


We provide: The capital, exchange accounts (Binance/Bybit/Hyperliquid), and infrastructure support.

You provide: The strategy logic and execution maintenance.
Structure: You receive a profit split (Performance Fee) on the PnL generated.

IP Rights: You retain 100% ownership of your source code and IP. We only require an exclusive license to trade the strategy for the duration of the engagement.

What We Are Looking For
We are interested in strategies focused on Crypto (Spot/Perps) or FX. We are specifically looking for:
Market Neutral / Delta Neutral: Arbitrage (Funding, Triangular, Calendar), Market Making, or Statistical Arbitrage.

Trend/Momentum: Only if accompanied by rigorous risk management (strict stop-losses).

Technical Requirements:
Proficiency in Python (Pandas, NumPy).
Experience with execution libraries (e.g., CCXT, Hummingbot) or custom WebSocket implementations.
Experience with backtesting frameworks (e.g., Lean, Backtrader, NautilusTrader, or custom vectorbt environments).
Understanding of Market Microstructure (order book dynamics, latency, slippage modeling).

Diligence Requirements (Read Carefully)
To filter out overfitting and theoretical models that fail in production, your proposal must demonstrate:
Slippage & Fee Modeling: Your backtests must account for Taker fees and realistic slippage.
Out-of-Sample Testing: Evidence that the strategy performs on data it wasn't trained on.
Drawdown Control: A defined Max Drawdown limit where the strategy halts.

Please link your GitHub repo or a screenshot of a live Sharpe ratio over 1.5 in your proposal.

Senior Embedded Vision / Data Capture Engineer (NOT a model training role)

🔍 Summary

We are building a road inspection device that records high-quality video + GNSS/IMU data for offline AI analysis.

We are not looking for a PyTorch/TensorFlow researcher.
We need an engineer who can design and implement a robust embedded video + sensor logging pipeline on an edge device.

If your primary experience is training YOLO models in Python, this role is not for you.


---

🎯 What this role is really about

Your main mission:

Take an industrial camera + GNSS + IMU + embedded board,

And turn it into a reliable “black box” recorder:

1080p video at stable 25–30 FPS,

synchronized GNSS/IMU timestamps,

data safely logged to SSD,

no frame drops, no random exposure jumps.



AI will run offline later.
Your focus is data capture, synchronization, and robustness, not model training.


---

✅ Required Core Skills (must-have, no exceptions)

Embedded Linux & C++

Strong C++ on Linux (not just Python/OpenCV scripts).

GStreamer and/or V4L2 for building low-latency camera pipelines.

Experience with:

multi-threading,

ring buffers,

back-pressure handling,

handling dropped frames, etc.



Industrial Camera Integration

Hands-on experience with USB3 / MIPI / GMSL industrial cameras.

Ability to configure:

exposure,

gain,

shutter,

resolution,

frame rate programmatically.


Understanding of rolling vs global shutter and impact on motion.


Sensor & Timestamp Handling

Reading GNSS (NMEA/UBX or similar) and IMU data streams.

Attaching accurate timestamps to each sensor sample.

Aligning sensor data with video frames (same clock / known latency).


Edge Device Engineering

Experience with Jetson Orin / Xavier / similar ARM-based embedded devices.

Designing video logging systems that:

write to SSD,

survive reboots / power glitches,

recover gracefully from errors.


Comfortable with Linux services, logging, debugging tools.


System-level Thinking

You have built real systems in the field, not just lab demos.

Can define clean interfaces for a hardware manufacturer:

“This is the API/connector/protocol we need”.


Can explain trade-offs: bitrate vs quality vs storage vs CPU load.



---

👍 Nice-to-have (NOT required, but helpful)

Experience with:

automotive or mobile robotics perception,

road / infrastructure imaging,

Shenzhen-based camera or box-build manufacturers.


Basic familiarity with TensorRT/ONNXRuntime only to the extent needed to run a pre-trained model (we can keep this minimal for MVP).



---

❌ This role is NOT for you if…

Please do NOT apply if:

Your main skill is:

PyTorch/TensorFlow model training,

computer vision research,

Kaggle-style experimentation.


You mostly work in:

Jupyter notebooks,

Google Colab,

cloud-only pipelines.


You have never:

built a real-time camera pipeline,

debugged dropped frames or sync issues,

worked directly with industrial cameras.



We respect ML/AI researchers — but this is an embedded systems & data pipeline role.


---

📦 Key Deliverables (January MVP)

For the first MVP (by end of January), we expect:

1. Working prototype on dev kit

1080p video capture at stable 25–30 FPS.

Known and measured latency from sensor to disk.



2. Synchronized logging

Video + GNSS (+ IMU if available) written with usable timestamps.

Simple format (e.g. MP4 + JSON/CSV metadata or similar).



3. Basic configuration tooling

Ability to adjust key camera params (exposure, gain, FPS).

Simple CLI or minimal UI for debugging & verification.



4. Documentation

Clear description of pipeline architecture.

Requirements for the hardware manufacturer (camera/box builder).




You will work closely with a Chinese camera manufacturer (hardware/firmware) and the product owner. Good written communication is important.

AI-Powered Teaching & Preaching App (React Native + AI Integration)
I am building a mobile app (iOS + Android) designed to function as a teaching and preaching assistant—similar to how I personally use AI to prepare sermons, lessons, devotionals, Bible studies, and teaching resources.
This is a well-defined MVP with a larger long-term vision. I am looking for an experienced developer who can build a strong, flexible foundation that can grow over time.
VISION
The goal of this app is to create anything related to teaching and preaching Scripture.
If it can be described in words, the app should be architected so it can be generated by AI.
The system should act as a content-generation engine for pastors, teachers, Bible study leaders, and ministry workers.
SUPPORTED INPUT TYPES
The app must be able to generate sermons and teachings from any of the following inputs:
1. Scripture-Based Input
User enters a Bible passage (example: John 3:16–21)
App generates a complete sermon or teaching from that passage
2. Subject or Biblical Theme
User enters a topic (example: forgiveness, anxiety, faith, church unity)
App identifies relevant Scripture and builds the teaching from it
3. Ideas or Everyday Life Situations
User describes a real-life situation or idea (example: grief, family conflict, burnout, stress at work)
App connects the situation to biblical truth and creates a teaching with Scripture and application
CORE OUTPUT (REQUIRED FOR MVP)
At minimum, the app must generate:
Title options
Introduction
Big idea / thesis statement
3-point sermon or teaching outline
Written-out Scripture (user-selectable Bible translation such as ESV, NIV, NKJV, KJV, etc.)
Explanation/teaching notes for each point
Application points
Conclusion
Small-group discussion questions
Content must clearly separate:
Scripture
Explanation
Application
EXTENDED OUTPUT TYPES (FUTURE PHASES – ARCHITECTURE REQUIRED)
The system must be architected so it can later generate (not required in MVP):
📘 Bible study lessons
📝 Teaching handouts / worksheets
📅 Daily devotionals
📊 PowerPoint / slide outlines
📖 Manuscript-style sermons
🧑‍🏫 Youth lessons
👨‍👩‍👧 Family devotionals
📚 Multi-week teaching series
⚠️ MVP scope is limited to sermon and lesson generation only.
These additional outputs are for future phases and should be supported by a flexible backend and prompt system.
TECH REQUIREMENTS
Frontend
React Native (single codebase for iOS + Android)
Simple, clean UI (speed and usability over design polish)
Backend
Node.js (preferred) or Python
REST API
Database: Firebase, Supabase, or PostgreSQL
AI
Integration with OpenAI or similar LLM API
Clean prompt handling with structured outputs
User Features
Email/password authentication
Save, edit, and reopen generated content
Basic content organization (saved items list)
DELIVERABLES
iOS TestFlight build
Android APK
Backend deployed
Source code
Basic documentation
PROJECT DETAILS
Project type: Fixed price
Budget: $6,000 USD
Timeline: 4–6 weeks (1–3 months max)
Experience level: Intermediate
Location: Worldwide
An NDA and IP ownership agreement will be required before sharing detailed prompts and internal logic.
IMPORTANT EXPECTATIONS
This is a clearly defined MVP
No over-engineering
No unnecessary features
Clean execution and communication are critical
Architecture should allow expansion without rewriting core systems
WHEN APPLYING, PLEASE INCLUDE:
Examples of React Native mobile apps you’ve built
Experience with AI / OpenAI / LLM APIs
Brief explanation of how you would structure the backend
Estimated timeline
Confirmation you can start immediately
👉 Please begin your proposal with the phrase:
“Sermon App Ready”
(This helps filter automated responses.)
WHAT SUCCESS LOOKS LIKE
App generates reliable, structured sermons and teachings
Scripture is accurate, written out, and clearly cited
Content is easy to save, reuse, and edit
MVP is ready for real-world pastors and teachers to use

**Job Overview**
I am an experienced futures options trader seeking an expert Quantitative Developer to build the core decision-making engine for a semi-automated trading system.

The strategy is a market-neutral, defined-risk hybrid derived from the "Time Flies" and "Flyagonal" concepts, specifically adapted for **S&P 500 E-Mini Futures (/ES) and their Options (FOPs)**. It seeks to capture Theta decay while hedging Vega risk by combining a **Put Diagonal Time Spread** (Vega Positive/Longer Duration) with a **Call Broken Wing Butterfly** (Vega Negative/Shorter Duration).

**Deliverable:** Backend logic, data ingestion, and an optimization model delivered as a web application. On a password protected webpage, I will click a "Generate Strikes" button, and the app will run and make a suggestion on which Strikes and Expirations would produce the optimal trade.

### **The Strategy Logic**

Your goal is to codify a rule-based system that scans the /ES option chain to construct a combined position consisting of:

1. **Downside Engine (Put Diagonal):** Selling near-term puts and buying longer-term puts (creating a "Time Spread" or "Diagonal") to benefit from volatility spikes on market drops.
2. **Upside Engine (Call Broken Wing Butterfly):** A standard BWB placed above the market to benefit from volatility contraction on market rallies.

**Objective:** The tool must ingest live data, generate thousands of process strike/expiry combinations for /ES FOPs, and rank their combinations based on a proprietary "Trade Score." The ideal Trade Score will be based on the best Expirations dates and Strikes that produce a safety zone that is within 2x of the Expected Move for the Front Month position, and balanced such that the center of the Shorts have the least amount of loss (if any) if the underlying ends up between the 2 Shorts.

#### **1. Architecture & Data Feed**

* **API Selection:** Recommend and integrate a cost-effective, reliable API capable of handling Futures Options data (e.g., ThinkOrSwim, Interactive Brokers, DataBento, or similar).
* *Requirement:* Must provide real-time or near real-time (snapshot) data for Option Greeks (IV, Delta, Gamma, Theta, Vega) and Bid/Ask spreads for /ES.
* *Optimization:* Data fetching should be limited to strikes within ~2x the Expected Move (EM) to minimize API load/latency.
* **Tech Stack:** Python (Pandas/NumPy/SciPy) is preferred for vectorization and speed.

#### **2. The "Entry Engine" (Scanner)**

Create a class/function that iterates through valid structures for the combined trade:

* **Inputs:** Front-month expiry (DTE \~7-10 days), Back-month expiry (for the Diagonal leg), and strike width parameters.
* **Scoring Logic:** Calculate a "Trade Score" for every valid combination:
* **Metric A (80% Weight):** Probability of Profit (POP) — *Developer must define how POP is approximated (e.g., using Delta or Monte Carlo simulation).*
* **Metric B (20% Weight):** Risk/Reward Ratio (specifically minimizing the Net Debit/Max Loss).
* **Output:** Return the Top 3 configurations ranked by Trade Score.

### **Required Skills & Qualifications**

* **Futures & Options Knowledge:** You must be familiar with /ES contract specifications, multipliers ($50 per point), and the unique nuances of Futures Options (FOPs) vs Equity Options.

* **Options Theory:** You must deeply understand the "Term Structure of Volatility." You need to know why we buy the back-month put (Vega hedge) and how Skew affects BWB pricing.

* **Quantitative Development:** Experience building back-testers, scanners, or pricing models in Python.

(Start your proposal with the code **"TFFA-ES"** so I know you read the full brief.)

* **API Integration:** Proven experience handling JSON/REST/Websocket data from financial APIs.

A Zoom interview with your camera turned on will be required. You must have a verified identity on Upwork.

• **API Recommendation:** In 1-2 sentences, which data provider would you suggest for "snapshot" futures options data and why? (You must have experience with that API and its settings)
• **Portfolio:** Briefly describe a relevant tool or scanner you have built (e.g., "I built a scanner for /NQ options using IBKR that did the following...").