Freelance python jobs for world-class Developers

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.

**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.

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 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

# 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...").

We are building a video bridge prototype using a Raspberry Pi Zero 2 W to control two specific ICs:

Lontium LT7911UXC (DisplayPort to MIPI Bridge)

Synaptics VMM5220 (MST Hub)

The Hard Part is Already Done: We have completed the R&D phase. We are not asking you to reverse engineer these chips. We possess the full engineering data package, including:

Source Code: The reference Linux Kernel Driver (.c file) with the full initialization sequence and register arrays.

Datasheets: The official BGA pinouts and register definitions.

Tools & Passwords: The proprietary configuration tools (VmmDPTool, LT Programmer) and the engineering unlock passwords to access hidden registers.

Schematics: The Reference Design (EVK) schematics.

Your Task: Your job is to take these resources and write a lightweight User-Space Initialization Script (in C or Python) that runs on the Raspberry Pi to wake up and configure these chips at boot.

• We provide a reference Linux Kernel driver (.c). Describe your workflow for extracting the register initialization arrays and porting them to a user-space Python/C script for the Raspberry Pi. How do you verify the sequence is correct?
• The Lontium chip boots at address 0x11 and only moves to 0x2B after a firmware upload. How will your script handle this specific handshake and firmware injection to ensure the chip is active before sending video timing commands?
• We have a proprietary config binary (.bin) for the Synaptics chip. How will you implement the routine to write this blob to the chip (Address 0x64) at boot using the Raspberry Pi? Would you use i2cset, Python, or fwupd?
• If the script runs but the chip does not ACK at address 0x2B, what are the first two things you would check regarding the Reset Pin timing and Power Rail sequencing to rule out hardware issues?
• Please acknowledge that we have already provided the Source Code, Datasheets, and Unlock Keys. Confirm you understand this is a Porting & Integration task, not a "Reverse Engineering" task.

About Us
PerfectServe is a leading healthcare SaaS company dedicated to improving communication and collaboration across clinical teams. We’re growing rapidly and looking for a skilled recruiter to help us identify and hire top technical talent.

Role Overview
We’re seeking a part-time Technical Recruiter (20–30 hours per week) to partner with our Talent Acquisition team. You’ll focus on sourcing, qualifying, and managing candidates for technical roles, including:

- Software Engineers (specializing in .NET and Python)
- Platform Engineers

All positions are fully remote within the US and some in Canada.

Responsibilities
- Review inbound applications through our ATS (Greenhouse)
- Source passive candidates through your own network and creative outreach strategies
- Conduct initial video interviews to qualify candidates before passing them to hiring managers
- Collaborate with the Manager of Talent Acquisition via Slack and Greenhouse
- Manage recruitment pipeline for 5–10 technical hires in Q1 2026
- Provide insights and recommendations on candidate quality and fit

Qualifications
- Proven experience recruiting for technical roles (software engineers, platform engineers, or similar)
- Strong sourcing skills and an established network of candidates in the tech space
- Experience using Greenhouse ATS (preferred)
- Ability to conduct professional, structured video interviews
- Excellent communication and organizational skills
- Keen eye for identifying top talent and cultural fit

Interested? Apply now with details about your technical recruiting experience, sourcing strategies, and familiarity with Greenhouse.

We are looking for a talented individual to complete three straightforward data visualization assignments. The ideal candidate should be proficient in creating clear and engaging visual representations of data. You will be provided with datasets and specific guidelines for each assignment. Strong attention to detail and the ability to deliver quality work within deadlines are essential. If you have experience in data visualization and a passion for storytelling through data, we would love to hear from you!

• What techniques would you use to clean a data set?

PLEASE SEE ATTACHMENT. We are seeking an experienced API integration specialist to connect Lightspeed POS X series with Google Sheets. The goal is to automate data transfer between the two platforms, ensuring real-time updates and seamless synchronization of sales and inventory data. The ideal candidate will have prior experience with similar integrations and be able to troubleshoot any issues that may arise during the process. If you have a strong understanding of APIs and are passionate about enhancing operational efficiency, we would love to hear from you!

• Describe your recent experience with similar projects