I have a production-ready React/TypeScript health record web application built with Lovable (AI app builder) that needs to be migrated to professional infrastructure I own before public launch. I also need Claude Code (Anthropic's AI coding CLI) set up so I can continue building features independently after migration without relying on Lovable. This is a one-time migration project with a clear scope and a complete data export already prepared. I need someone experienced, detail-oriented, and trustworthy — this is a health application handling sensitive patient data. What I already have: Vercel Pro account — ready to connect Supabase account — ready to create new project GitHub repository — connected and available Domain: fullycharted.app — DNS access available Complete bulk export ZIP from Lovable Cloud — all tables as CSV/JSON, all storage files, complete supabase/migrations/ folder 2 beta users currently — minimal data to migrate Mac computer for local development setup The application: React/TypeScript frontend with Vite and TailwindCSS Supabase backend — PostgreSQL, Row Level Security, Edge Functions, Storage buckets Supabase Auth for authentication 1,326 automated tests passing Currently hosted on Lovable Cloud fullycharted.app currently points to a separate landing page — needs to point to the full app after migration What I need done: Connect GitHub to my Vercel account and configure build settings for Vite/React and all environment variables Create new Supabase project in my account — run supabase db push using migrations folder, import all table data from CSV/JSON export, re-upload all storage files (lab documents, imaging, diagnostic studies), verify all Row Level Security policies working correctly Configure all environment variables — VITE_SUPABASE_URL, VITE_SUPABASE_PUBLISHABLE_KEY, VITE_ADMIN_EMAIL, and any others currently in Lovable DNS configuration — point fullycharted.app to Vercel, configure www redirect, verify SSL certificate Handle 2 beta user accounts — coordinate password reset timing before DNS cutover Full verification — app loads at fullycharted.app, login works, patient data intact, emergency view works without auth, file uploads work, admin route gated correctly, all 1,326 automated tests pass, RLS verified (no cross-account data access) Claude Code setup on my Mac — install Node.js, install Claude Code CLI, clone repository locally, configure local environment variables, verify app runs locally (npm run dev) and tests pass (npm test), walk me through one simple change so I understand the workflow Documentation and handoff — all environment variables documented, Vercel and Supabase configuration documented, local development workflow documented, GitHub push triggers Vercel deployment confirmed Security requirements: This is a health application. RLS policies must be verified after migration. Patients must only access their own data. Admin route gated to one specific email. Public emergency routes work without exposing other patient data. What I will provide: Access to my Vercel account Access to my Supabase account Complete bulk export ZIP GitHub repository access Domain registrar access for DNS Anthropic API key for Claude Code Quick responses throughout the project Success looks like: fullycharted.app loads the full application Beta users can reset password and log in with all data intact All 1,326 tests passing I own all infrastructure completely Claude Code installed, configured, working Complete documentation in my hands Follow-on work: I have a second application (MySynapse — homeschool platform) on the same stack needing the same migration in 1-2 months. Strong performance here leads to that second project directly. To apply please include: Examples of similar Lovable/managed platform to Vercel migrations Supabase RLS and migration experience Your approach to data integrity verification Confirmation you are comfortable with health app security requirements

We're seeking an experienced developer or agency to create a premium, modern website for a subscription-based platform. The project involves integrating AI technologies with Next.js to enhance user experience. The ideal candidate will have a strong background in web development and a keen eye for design.

Core Architectural Workflow 1. Client Intake & Data Collection The customer visits the Porkbun-hosted website and completes a secure, multi-step intake form. The form dynamically captures customer details, the specified number of signers, and handles secure multi-file document uploads. 2. Asynchronous API Triggering Blue Notary API: The website backend instantly delivers an API payload to Blue Notary to establish the live signing session container, pushing the customer data and uploaded document streams directly into the digital meeting room. QuickBooks Online API: Simultaneously, the backend contacts QuickBooks to check for an existing client record or generate a new Customer Profile. 3. Credit Card Tokenization (Vaulting) To maintain absolute data security and avoid PCI-compliance liabilities, the developer will embed the QuickBooks Web Payments SDK directly into the booking page. When the client clicks "Book," the secure iframe captures and tokenizes the credit card information with QuickBooks Payments, returning a secure payment token (paymentMethodToken). The website backend securely maps this token to the customer profile for later use; no actual credit card numbers are ever stored on our servers. 4. Post-Session Admin Portal & Dynamic Billing Because RON platforms track identity verification but do not consistently pass live, rolling digital stamp/seal counts to external billing systems in real time, the developer will construct a secure, password-protected administrative interface on our domain (e.g., /admin/billing). Upon logging out of a completed Blue Notary session, the admin opens this dashboard, selects the client, and types in the Actual Signers and Actual Seals Placed. Automated Billing Logic Formula Upon submitting the administrative form, the server executes the programmatic pricing formula: Total Invoice = Base Session Fee + (Additional Signers × Signer Rate) + (Additional Seals × Seal Rate) The backend automatically executes these final steps via the QuickBooks API: Generates a professional line-item invoice reflecting the base fee and exact volume variables. Commands QuickBooks Payments to immediately process the charge using the vaulted credit card token. Locks in the clean processing rate (e.g., flat 2.99% invoiced rate) with zero added per-transaction service fees or third-party overhead. Triggers the automated delivery of the official QuickBooks paid receipt directly to the client's inbox. Developer Job Posting Copy Project Overview: Looking for a talented full-stack developer to redesign/update a website hosted on Porkbun, build a custom multi-signer intake form with secure document upload, and integrate direct, custom backend automations with Blue Notary and QuickBooks Online. No third-party automation tools (Zapier/Make) are permitted. Key Deliverables: Frontend Intake Form: Clean, mobile-responsive design allowing secure file uploads and dynamic forms based on input signer counts. Direct Blue Notary Integration: Connect to Blue Notary’s REST API to instantly initiate a session and pass files upon customer submission. QuickBooks Payments SDK Integration: Implement secure credit card vaulting/tokenization at intake using the official QuickBooks Web Payments SDK. Admin Post-Session Billing Tool: Create a lightweight, secure internal portal where the admin inputs final signer and seal counts. Automated Invoicing Engine: Calculate the final pricing via code on admin submission, generate a line-item invoice in QuickBooks, charge the vaulted card token automatically, and trigger the receipt. Technical Requirements: Proven experience with backend languages (Node.js, Python, PHP, or Go). Deep familiarity with QuickBooks Online Accounting & Payments APIs (specifically tokenized card charges and invoice generation). Strong understanding of REST APIs, webhooks, JSON payloads, and secure file handling over HTTPS. Ability to deliver clean, documented, standalone code without external platform dependencies.

I have a functional React application built with Vite and Tailwind CSS. The core logic, component structure (App.jsx), and UI assets are complete and working as intended. However, I am encountering build/deployment errors on Netlify, likely due to a cluttered package.json and configuration inconsistencies developed during iteration. This is a quick job but ultimately need help getting it across the finish line (ideally today). The Goal: I am looking for an experienced React developer to perform a "clean room" migration. Instead of debugging the current build environment, I need you to: 1. Initialize a fresh, standard Vite + React project. 2. Migrate my existing App.jsx logic and all static image assets into this new, clean repository. 3. Ensure the project builds successfully and deploys cleanly to Netlify.

Here is what we have so far , a zapier website form that once submitted for a ride request triggers my sms approved twilio number to send me a text with the requested ride info ( lighting fast ) what wouldbe better is Twilio Expert to Build Dispatch Broadcast & Lockout System via Functions & Studio Project Description: We run a local Free community micro courtesy shuttle business utilizing a fleet of 6 gas-powered passenger vans. We need a backend developer to build a text-message-based dispatching system using Twilio Studio, Twilio Functions, and Twilio Sync for data tracking. Core Workflow Required: Web Request Ingestion: Webhook takes ride data (Name, Pickup, Dropoff, Resident Status, Pax count). Active Schedule Check: System checks an internal list of active, on-duty drivers (needs an easy way for me to update weekly schedules or toggles). Simultaneous SMS Broadcast: Send a ride text to only the active drivers on-duty right now. First Responder Wins (Lockout Logic): When a driver replies with a number (e.g., "15"), a Twilio Function checks Twilio Sync. If the ride is still unclaimed, lock it to that driver, store their name and their inputted ETA, and mark the ride as "Claimed". Late drivers must get an automated "Already claimed" text back. Customer Interactive Flow: Trigger a Twilio Studio flow to text the customer: "Your ride is confirmed! [Driver Name] will arrive in [ETA] minutes. Reply CANCEL within 3 minutes if you don't want to wait." Handle customer cancellation loops cleanly. Archival: Push all completed or canceled ride data to a permanent history log. Requirements: Deep experience with Twilio Node.js runtime environments. Proven experience managing race conditions via Twilio Sync Maps/Documents. Ability to build clean, well-commented code so non-technical owners can easily swap out driver lists/phone numbers. Step 2: Prepare Your System Specs (Before the First Call) To keep this fast and budget-friendly, hand developer clean blueprint of your data structure on day one. Have an Excel or Google Sheet ready that maps out exactly what you want tracked: Driver Name Driver Phone Shift Day Start Hour End Hour Status (On/Off Duty) Driver 1 +1727xxxxxxxx Monday 08:00 16:00 Active Driver 2 +1727xxxxxxxx Monday 16:00 23:00 Off-Duty “Can we use Twilio Sync to manage this schedule list, or would it be easier to have the Twilio Function pull this table dynamically from a Google Sheet using the Google Sheets API?” Step 3: Execution and Safeguards the milestone payments based on clear deliverables: Milestone 1 (Setup & Simulation): The developer creates the Twilio Sync environment and proves that if they send two simulate driver texts at the exact same second, one gets the ride and the other gets locked out. Milestone 2 (Studio Integration): The customer text sends successfully with the winning driver's name and ETA, and replying "CANCEL" triggers the cancellation text back to the driver. Milestone 3 (Live Beta Test): I stand on the beach with 2 or 3 of my drivers on a Tuesday afternoon. i hit submit on your webpage, watch the phones drop the texts, claim the ride, and verify the customer workflow. let me know what I missed ?

Note: We are a well-funded startup with a very high engineering bar, working alongside senior engineers with experience from leading AI labs. This is a smaller initial paid task, but we pay well for excellent work and there is potential for a much larger collaboration if the fit is strong. Your PRs will be reviewed by strong engineers, so we are looking for someone who takes ownership, thinks clearly, and cares about shipping clean, production-ready code. Please only apply if you can hold yourself to that standard. We are not looking for generic AI-generated output or low-effort execution. # Implement Probabilistic Attribution Between Marketing Website and Electron Desktop App We have a marketing website where users can click to download our Mac desktop app. The app is distributed as a standard Mac DMG and built with Electron. We use PostHog for product analytics, and we also run Google Ads. Users may eventually sign in inside the desktop app through ChatGPT/auth, but many users will first be anonymous. We want to implement a simple first version of attribution that helps us understand which website visitors / ad campaigns / download clicks later become desktop app users. ## Goal Build a lightweight probabilistic matching system that connects: 1. A user visiting the marketing website 2. The same user clicking “Download” for the Mac DMG 3. The desktop app being opened for the first time 4. The user later signing in, when applicable The goal is not perfect identity matching. The goal is good-enough attribution for our current low-volume flow, roughly around 100 download clicks per week. ## What needs to be figured out The developer should determine the best simple implementation for: - Capturing enough information on the marketing website when someone clicks the Mac download button - Capturing enough information from the Electron app on first open - Matching those two events probabilistically on the backend - Passing useful attribution information into PostHog events - Associating the attribution with the authenticated user once the user signs in - Testing that the full flow works end-to-end The likely matching signals are things like timestamp proximity, hashed IP, platform, timezone, language/locale, and other non-invasive browser/app context. The implementation should avoid overcomplicated or privacy-invasive fingerprinting. ## What we should do Implement a simple backend-backed attribution flow: - When someone clicks “Download for Mac” on the website, create a download-attribution record. - Capture campaign data such as UTMs, Google Ads click ID if present, landing page, referrer, and PostHog anonymous/browser ID where available. - When the Electron app first opens, create or retrieve a persistent app install ID. - Send a first-open event from the app to the backend. - Backend attempts to match that first app open to a recent download click. - Store the match with a confidence level such as high/medium/low/unmatched. - Send attribution metadata as properties on relevant PostHog events. - Once the user signs in, connect the app install and attribution record to the authenticated user ID. ## What we should not do in this version We do not want to overbuild this. Do not: - Generate a unique DMG per user - Modify the signed Mac app bundle - Inject tokens into the installer - Implement custom deep links yet - Build a full deterministic attribution system - Use probabilistic matching to permanently merge PostHog user identities - Send raw IP addresses to PostHog - Add invasive browser fingerprinting Probabilistic attribution should be treated as estimated attribution, not as guaranteed user identity. ## Expected deliverables The task is complete when: - The website download flow records download intent and campaign metadata. - The Electron app records first-open/install metadata. - The backend can probabilistically match app first opens to recent website download clicks. - PostHog receives app events with attribution properties when a match exists. - The system links the app install to the authenticated user after sign-in. - There is a way to inspect/debug attribution matches. - The implementation is tested locally or in staging with realistic flows: - normal download → immediate app open - delayed app open - no matching download - multiple download clicks from the same network - user signs in after opening the app ## Important constraint This is a first version. We prefer a simple and maintainable solution that gives us useful attribution data over a complex solution that tries to be perfectly accurate.

I am seeking an experienced Automation / Embedded Systems Engineer to develop a robust, custom, production-ready Linux operating system image for a Raspberry Pi 3B+. The goal of this project is to create a 100% open-source, license-free "Gold Master" image that mimics a Unitronics smart relay/PLC workflow. This image will eventually be cloned across hundreds of offline poultry houses across a large-scale agricultural infrastructure. 🛠️ Hardware Stack (Target Environment) Controller: Raspberry Pi 3B+ booted completely offline (no internet access). Shield Stack: Sequent Microsystems Building Automation HAT + Sequent Stackable Smart UPS HAT (communicating via I2C). Display: Industrial HDMI Touchscreen. Power: 220V AC input stepped down via DIN-rail Mean Well power supplies (24V DC feeding the UPS HAT, separate line feeding the HDMI monitor). Outputs: On-board pilot relays triggering heavy-duty 220V AC industrial contactors/SSRs for high-voltage motors, heating, and lighting. 📋 Software & System Requirements Zero-Licensing Architecture: The entire system must utilize an open-source automation stack. We are using OpenPLC for the IEC 61131-3 visual ladder logic execution engine and Node-RED for the drag-and-drop HMI user interface. OS Hardening & Kiosk Mode: Built on Raspberry Pi OS Lite. The system must boot directly into a full-screen, fullscreen Chromium --kiosk browser pointing to the local Node-RED dashboard interface. There must be zero access to the underlying Linux terminal or desktop for farm operators. Display Power Management (DPMS): The system must utilize Linux screen blanking. The touchscreen backlight must completely power down after 5 minutes of inactivity and wake instantly back to the active HMI screen upon a physical touch event. Hardware Timekeeping (Offline): Synchronize the Linux system clock seamlessly on boot from the Sequent board’s battery-backed DS3231 Hardware RTC chip (hwclock) so the system maintains absolute real-world time accuracy without internet connectivity. Power Fail Resiliency & Retentive State: The software must listen to the Sequent UPS HAT. Upon 220V main power drop, a script must cleanly save current timer registers to retentive storage, write an event log, and execute a safe Linux shutdown to prevent SD card corruption. On power restoration, it must read the file and resume the cycle state seamlessly. HMI Password Protection: Implement a supervisor password/PIN keypad screen on the Node-RED interface, preventing unauthorized workers from modifying the timer settings. Data Logging & Audit Trail: Program local data logging (CSV or SQLite) to the SD card. It must record boot events, power losses, user logins, relay actions (start/stop), and track old vs. new values when configurations are edited. File writes must be buffered to optimize RAM and minimize SD card wear. Mass Replication Design: The image must be completely abstracted. All local variables (e.g., unique House ID, specific timer intervals) must be read from a local config file. Supervisors must be able to change these local configurations via the password-protected HMI screen so that the exact same master .img can be flashed onto hundreds of identical devices without code changes. 📦 Required Deliverables A single, universal flashable .img file ready to be duplicated onto standard SD cards. Clean, well-documented source code files for the OpenPLC logic and Node-RED flows. A highly clear, visual electrical wiring schematic showing exactly how the Pi, the Sequent HAT stack, the Mean Well power supplies, and the 220V contactors interconnect safely.

Before you apply read this first.: This is not a standard contract. We are not looking for someone to build something and disappear. We are looking for a developer who genuinely cares about people experiencing homelessness and wants to be part of something that actually changes lives. If that is not you, this post is not for you. If it is keep reading. What Is Operation Iron Gate: Operation Iron Gate is a physical intake hub in Vallejo, California built specifically for the unsheltered. Any homeless person can walk through our door and receive help no matter what barriers they are carrying, no matter what their documentation looks like, no matter how many times they have been turned away before. The rule is simple: nobody gets denied. We call it Yes by Default. Instead of looking for reasons to say no, we look for the next valid move. Every single time.When someone walks in, a case gets opened immediately. Every barrier they are facing gets documented. A next step gets started before they leave the building. And the system tracks every single movement of that case every action, every referral, every handoff until they actually receive the resource they need. Not a phone number on a piece of paper. The actual resource. It sounds too good to be true. That is exactly why we built the technology to make it real. What You Are Building — Phase 1 Only: We are currently hiring for Phase 1 only. This is the core platform build. We are keeping it focused. Once the pilot launches in Vallejo and the system is proven in the real world, we will move into the AI layer and long-term development. But right now we need Phase 1 built right. The platform is called DSAS the Digital Steward Authorization System. It is the brain of Operation Iron Gate. Here is what Phase 1 covers: * Case creation engine when someone walks through the door, a case opens immediately. One screen, one submit. * Barrier capture system every barrier the person is facing gets documented and connected to a next action. * Yes by Default enforcement a denial without a legal reason code is blocked by the system itself at the database level. * Three-tier triage system urgent cases get a 2-hour movement deadline with auto-calculated countdown. * Steward escalation queue hard cases route instantly to senior reviewers who make binding decisions. * MDO Live View: real-time monitoring screen showing every active case, who owns it, where it is stuck, how long it has been sitting. * Automated alert engine fires when a case stalls, when a deadline is missed, when a partner does not respond. * Glass Dashboard public-facing transparency layer showing the community how the system is performing in real time. * All data feeds automatically from the system. No manual entry ever. * IGAC credential system when someone arrives without ID, a credential is issued immediately on Day 1 so the case can keep moving. * 7-role permission matrix enforced at the API level on every endpoint. * Append-only audit trail tamper-evidence logging. Nothing gets deleted or edited after it is written.. The full technical specification is already built: * Every database field is named. * Every logic rule is written. * Every automated alert is defined. * Every role permission is mapped. You are not figuring out what to build. You are building something that is completely designed and ready to be coded. Technical Requirements Required: * Strong backend / full-stack development 3+ years building complex platforms * Relational database expertise PostgreSQL or MySQL complex logic enforced at the database level * Role-based access control enforced at the API level * Automated alert engines time-based and condition-based triggers * Append-only audit logging with tamper evidence * Real-time data feeds * REST API development Strongly preferred: React or similar framework for front-end interfaces. Mobile-responsive design Access Points may operate from tablets and phones. Civic tech, social services, healthcare, or government platform experience. We are open to your stack recommendation. Tell us what you would use and why. Who We Are Looking For: We need someone who is technically strong. But more than that we need someone who reads about Operation Iron Gate and feels something. Someone who understands that every field in this database is a real person's life. Someone who will flag a problem in the spec before building it wrong. Someone who stays when things get hard. Someone who wants to be part of this mission not just compensated for it. If you are only here for the money, this is not the right fit. If you want to build something that matters we want to talk to you. Compensation: Read This Carefully: This is a fixed-price contract via Upwork with milestone-based payments. Here is exactly how it works and why we structured it this way. We are paying in four milestones. Every single payment is tied to something real being delivered and confirmed not just promised. * 25% on project start you have skin in the game from day one and so do we. * 25% when the database and core logic is confirmed complete confirmed by the developer handoff checklist, not by your word alone. * 25% when the full intake flow and MDO Live View is confirmed complete again, confirmed by the checklist. * 25% at final sign-off when every single item on every Tier 1 handoff checklist is confirmed complete Nobody gets paid until something real is delivered and confirmed. The checklist is the protection for both of us. You cannot say something is done and collect payment if the checklist says otherwise. That is not a lack of trust that is how professional projects get built correctly. There is one more thing we need in this contract and we want to be upfront about it. The contract will include a scope change clause. That means if we ask you to build something that was not in the original specification something we did not think of, something new that becomes a change order and gets priced separately. It does not get quietly absorbed into the fixed price and it does not become a source of resentment on either side. You build what is specified. Anything beyond that gets negotiated openly and fairly. Fixed rate. Milestone payments. Handoff checklist as the payment trigger. Scope change clause in the contract. That is how we protect Pathfinders for Hope's mission funding and make sure you get treated fairly too. Additional terms: * NDA required before any specifications are shared * Work-for-Hire Agreement required before development begins all code belongs to Pathfinders for Hope * Rate is negotiable based on experience To Apply: Submit your proposal with your answers to all eight questions, a description of your most relevant project, your recommended stack, your honest Phase 1 timeline estimate, and your rate. We are building the operating system that proves homelessness can be solved one city at a time. If that is the kind of work you have been waiting for, we want to hear from you.

We’re hiring an extraordinary developer to own and grow our Base44 apps and sales products. around the future of AI discovery 1. Future of AI Discovery Core Demo – https://pull-discovery-core.base44.app/ You’ll evolve https://pull-discovery-core.base44.app/ into a beautiful, fluid, high‑performance, full-functional future of AI discovery demo following our advanced and sophisticated technical blueprint Integrate and orchestrate AI models incorporating LLM's, Search and World Models into a seamless experience with no visible seams between UX and intelligence. Own front‑end performance, responsiveness, and micro‑interactions—animations, transitions, and state changes should feel intentional and “alive,” not bolted on. Implement robust logging and analytics to understand how users explore, where they get stuck, and how the discovery engine can adapt dynamically. 2. Book Sales Engine – Six‑Channel Publishing System The second current Base44 project is a system that operationalizes our comprehensive sales plan across six channels. SEE THE COMPREHENSIVE BOOKSALES PLAN ATTACHMENT UNDERNEATH THIS POSTING You will: Translate a detailed multi‑channel publishing strategy (KDP optimization, physical bookstores via IngramSpark, other digital platforms, libraries, bulk institutional sales, and authority‑engine content marketing) into concrete workflows, tools, and dashboards. Build internal interfaces and automations to: Track metadata, pricing, and promotions across Amazon KDP and other platforms. Monitor campaigns across TikTok, Meta, LinkedIn, YouTube, newsletters, and partnerships. Surface KPIs like BSR, review velocity, ad spend, email growth, library adoptions, and bulk orders in a single, coherent view. Design light internal UIs that make it easy for non‑technical team members to update copy, add titles, trigger campaigns, and view performance without breaking anything. Implement robust, testable integrations between Base44, external APIs, and data sources to keep everything in sync as we scale from 8 to 22+ titles and beyond. Who You Are We’re not looking for a generic “full‑stack dev.” We’re looking for an unusual combination of visionary and doer: Creative technologist mindset – You think in systems and interfaces at the same time. You care deeply about how a product feels as well as how it works. Obsessed with execution – You’re disciplined, structured, and relentless about shipping. You break ambiguity into sprints, reduce complexity into tickets, and never let projects stall. Proactive owner – You don’t wait for instructions. You propose better ways to do things, flag risks early, and bring options—not problems—to every conversation. Strong product sense – You can balance ideal UX with realistic constraints and understand when to ship v1 vs. when to invest in polish. Comfortable with complexity – Multi‑channel distribution, layered data flows, and evolving requirements don’t scare you; they energize you. Ideal Skills & Experience You don’t need all of these, but you should recognize yourself in most: 5+ years building production web applications, ideally with a strong front‑end/UI focus. Deep experience with modern web stacks (React/Vue/Svelte or similar) and TypeScript, plus comfort with Node or comparable back‑end runtimes. Strong visual/UI instincts: experience collaborating with designers or owning design yourself for data‑rich interfaces and dashboards. Experience integrating AI/LLM APIs and retrieval systems into real products (RAG flows, multi‑step tool use, chat‑like interfaces, recommendation engines). Experience with analytics and experimentation: event tracking, funnel analysis, A/B testing. Familiarity with publishing, ecommerce, or multi‑channel marketing systems is a plus (KDP, IngramSpark, email platforms, ad platforms, analytics). Prior work in environments like Base44 or other low‑code/agentic platforms is a strong plus, but not required if you learn fast.

I need an expert senior software engineer that can provide consulting services around implementation best practices of LLM's and AI into existing application workflows. i.e. leveraging AI to extract data from a document as part of an ingestion pipeline.