Python Dash Plotly Jobs (Flexible Options) in Oregon

Founding Lead Engineer / Principal Systems Architect

Evidence-Governed AI/Data Platform

Location: Remote / Hybrid
Employment Type: Full-time
Seniority: Principal / Staff-level
Experience: 8-12+ years preferred, or equivalent exceptional experience

About the Role

We are building a confidential intelligent operations platform for evidence-governed analysis, operational reconstruction, model-assisted workflows, and high-integrity reporting in regulated domains. The first deployment focuses on healthcare integrity, provider-level identity mapping, licensing, ownership, source reconciliation, and defensible review workflows.

We are seeking a hands-on Founding Lead Engineer / Principal Systems Architect to work directly with the concept architect and translate a large, complex system vision into production-grade software, data architecture, model integrations, validation harnesses, and secure Kubernetes-based deployment infrastructure.

This is not a standard software engineering role. This is a founding technical role for building the core architecture of a serious AI/data platform from the ground up. The right candidate must be able to absorb abstract system concepts in real time and convert them into schemas, APIs, service boundaries, deployment artifacts, validation tests, and pragmatic engineering roadmaps.

What You Will Build

You will lay the technical foundation for a modular, enterprise-scale AI/data platform, including:

• canonical identity and entity-resolution services;
• source registry and evidence-management services;
• provider-level healthcare integrity workflows;
• relational, graph, object-store, retrieval, and audit data layers;
• deterministic rules and validation services;
• model-adapter and multi-model routing layers;
• structured-output and model-evaluation workflows;
• human-in-the-loop review workflows;
• graph, timeline, and evidence-review prototypes;
• evidence-linked reporting;
• audit logging and compliance-supporting records;
• secure Kubernetes / cloud / private-infrastructure deployment;
• validation, benchmark, and regression harnesses.

The first deployment will focus on provider-level healthcare integrity. Future deployments may extend into other regulated and high-consequence domains, including legal, financial, AI governance, cyber, public-sector, operational risk, and training/simulation environments.

Key Responsibilities

Concept-to-Code Translation

• Work side-by-side with the concept architect to convert advanced system ideas into technical specifications, service maps, data models, APIs, schemas, tests, and deployment plans.
• Translate verbal and written design guidance into architecture diagrams, implementation backlogs, acceptance criteria, and working prototypes.
• Identify ambiguity, missing assumptions, engineering risks, security issues, and implementation conflicts.
• Help turn an evolving concept architecture into reproducible, testable, maintainable software.

Backend and Platform Engineering

• Build production-grade Python services, APIs, data pipelines, background workers, and orchestration logic.
• Design clean service boundaries for ingestion, entity resolution, evidence management, review workflows, reporting, audit logging, and model integration.
• Build deterministic, auditable workflows for high-consequence system operations.
• Establish repository structure, coding standards, documentation practices, testing standards, and implementation discipline.

Data, Graph, and Knowledge Architecture

• Design and implement relational schemas, graph models, object-storage structures, retrieval indexes, and audit records.
• Build canonical identity and entity-linking systems that reconcile conflicting real-world records.
• Support relationship topology, ownership mapping, provider-network analysis, and source-conflict preservation.
• Implement data validation, source normalization, evidence linking, deduplication, and data-quality checks.

AI / LLM Systems Engineering

• Build a model-agnostic adapter layer for open-weight and hosted models.
• Implement multi-model routing for parsing, extraction, summarization, evidence explanation, report drafting, reviewer critique, and deterministic no-model workflows.
• Integrate model-serving infrastructure such as vLLM, KServe, Ray Serve, Ollama, llama.cpp, Hugging Face, or equivalent tools where appropriate.
• Implement structured outputs, prompt/template management, model-call audit, output validation, and model versioning.
• Ensure model outputs remain constrained by evidence, rules, schemas, human review, and audit records.

Human-in-the-Loop Review and Visualization

• Build rapid internal UI prototypes for evidence review, graph visualization, timeline inspection, review queues, report review, and audit inspection.
• Use tools such as Streamlit, Plotly Dash, Retool, React, Next.js, or equivalent frameworks where appropriate.
• Design backend APIs and data contracts that allow a dedicated frontend or full-stack engineer to later build a production analyst/reviewer workspace.
• Ensure human reviewers can inspect evidence, source conflicts, model outputs, rule triggers, and report language before high-consequence outputs are finalized.

Infrastructure, DevSecOps, and Deployment

• Deploy services using Docker, Kubernetes, Helm, GitOps, CI/CD, RBAC, secrets management, observability, and secure environment practices.
• Support cloud, private-cloud, hybrid, or OpenTeams/Nebari-aligned infrastructure where applicable.
• Implement secure configuration, environment promotion, logging, backup/restore, and infrastructure-as-code practices.
• Build deployment patterns that can support development, test, staging, and controlled pilot environments.

Validation, Evaluation, and Benchmarking

• Build synthetic datasets, golden tests, regression tests, benchmark suites, schema tests, model-output checks, and security-boundary tests.
• Validate ingestion throughput, entity-resolution accuracy, graph query performance, model latency, report generation, audit volume, and backup/restore behavior.
• Ensure every major module has clear acceptance criteria and reproducible test evidence.

Required Qualifications

• 8+ years of professional software engineering experience, or equivalent exceptional experience.
• Expert-level Python engineering.
• Experience building production backend services, APIs, data pipelines, and distributed systems.
• Strong SQL and relational database design experience, preferably PostgreSQL.
• Experience with graph databases, knowledge graphs, or complex relationship modeling.
• Experience with LLM integration, open-weight models, structured outputs, prompt/template management, or model-evaluation workflows.
• Experience with Docker, Kubernetes, Helm, GitOps, CI/CD, and secure cloud or private infrastructure deployment.
• Experience with data validation, audit logging, RBAC, secrets management, and secure software design.
• Ability to design modular systems from ambiguous early-stage architecture.
• Ability to translate non-engineering conceptual guidance into concrete software architecture and implementation plans.
• Strong written documentation skills.
• Comfort working directly with a non-engineer concept architect.

Strongly Preferred Qualifications

• Experience with Nebari, Dask Gateway, Keycloak, or comparable data-platform infrastructure.
• Experience with vLLM, KServe, Ray Serve, Ollama, llama.cpp, Hugging Face Transformers, or comparable model-serving infrastructure.
• Experience with Neo4j, Cypher, graph analytics, graph ETL, or graph visualization.
• Experience with OPA/Rego, policy-as-code, deterministic rule engines, symbolic validation, or explainable decision logic.
• Experience with FastAPI, Pydantic, SQLAlchemy, Alembic, pytest, and modern Python service design.
• Experience with Terraform, ArgoCD, Flux, Vault, Prometheus, Grafana, OpenTelemetry, or comparable DevSecOps tooling.
• Experience with vector databases, hybrid retrieval, pgvector, OpenSearch, Elasticsearch, or comparable retrieval systems.
• Experience with Dask, Spark, Kafka, Redpanda, RabbitMQ, or comparable distributed processing and event-streaming systems.
• Experience in healthcare, government, legal, finance, cybersecurity, program integrity, or other regulated environments.
• Familiarity with provider enrollment, NPI/NPPES, PECOS, LEIE/exclusion references, licensing records, corporate registries, or healthcare integrity workflows.
• Familiarity with EDI healthcare transactions, eligibility files, managed-care encounters, FHIR, HL7, or EHR audit logs is helpful for later expansion phases.
• Experience building AI systems with human review, auditability, evidence controls, and high-consequence output safeguards.
• Experience with private-cloud, on-prem, hybrid, or air-gapped deployments.

Applied Mathematics and Algorithmic Skills

The ideal candidate should be comfortable translating analytical concepts into efficient production code, including:

• graph algorithms and centrality measures;
• entity-resolution and record-linkage logic;
• scoring systems and weighted evidence models;
• time-series and temporal-pattern analysis;
• recurrence or longitudinal-pattern analysis;
• statistical validation and benchmarking;
• performance optimization for large structured datasets.

The candidate does not need to be a research mathematician, but must be able to turn analytical concepts into practical, testable, and efficient software.

Working Style

We are looking for someone who is:

• a hands-on builder;
• a systems thinker;
• a concept-to-code translator;
• security-conscious;
• evidence-driven;
• comfortable with ambiguity;
• direct and clear in communication;
• willing to challenge weak assumptions;
• disciplined about documentation;
• strong at decomposing complex systems;
• able to prototype quickly and harden later;
• capable of prioritizing ruthlessly;
• comfortable working on sensitive regulated-domain systems.

The right candidate does not wait for perfect Jira tickets. They can listen to an abstract concept, map it on a whiteboard, identify the technical implications, and begin shaping the schema, API, test plan, and implementation path.

What This Role Is Not

• This is not a prompt-engineering role.
• This is not a chatbot-wrapper role.
• This is not a pure data-science role.
• This is not a pure cloud-administration role.
• This is not a pure frontend role, although rapid UI prototyping is expected.
• This is not a role for someone who only builds API wrappers or proof-of-concept AI agents.

This is a founding technical role for constructing a serious, evidence-governed AI/data platform.

First 30 / 60 / 90 Days

First 30 Days

Expected outcomes:

• establish repository structure;
• create architecture decision records;
• define initial service map;
• define initial database and graph schemas;
• build local development environment;
• create API skeleton;
• create CI/CD skeleton;
• create database migration skeleton;
• create model adapter stub;
• create validation harness skeleton;
• document open infrastructure and deployment questions.

First 60 Days

Expected outcomes:

• build ingestion prototype;
• build canonical identity/entity-resolution prototype;
• build source registry prototype;
• build evidence-management prototype;
• build graph relationship prototype;
• add audit logging;
• add deterministic rule and review workflow skeleton;
• generate basic evidence-linked outputs using synthetic or approved data;
• build first internal review/visualization prototype.

First 90 Days

Expected outcomes:

• produce deployable first-lane pilot prototype;
• add model-serving integration;
• add graph and review UI prototype;
• add validation suite;
• produce benchmark results;
• establish secure Kubernetes / Nebari / equivalent deployment path;
• produce implementation backlog for next-stage expansion.

Interview Process

The interview process is designed to test real-world capability, not resume keywords.

It may include:

1. Architecture discussion
   Explain how you would build source ingestion, identity resolution, evidence management, graph relationships, rule triggers, review queues, report outputs, and audit logs.
2. Concept translation exercise
   Convert an abstract system concept into a service map, data schema, API plan, test plan, and implementation backlog.
3. Technical implementation exercise
   Outline or build a small ingestion and entity-resolution prototype.
4. Infrastructure design discussion
   Explain how you would deploy the prototype with Kubernetes, Helm, secrets, RBAC, observability, and CI/CD.
5. AI/model systems discussion
   Explain model adapters, multi-model routing, structured outputs, prompt templates, model-call audit, and hallucination prevention.
6. Security scenario
   Explain what happens if a prohibited data type is uploaded into a restricted environment.
7. Pair working session
   Work directly with the concept architect to translate a verbal concept into an implementation plan.

Compensation

Competitive compensation based on experience.

Equity, performance-based incentives, or founding...