Active Right NowUpdated April 2026

Kyle Barnette

Software Engineer | Backend, Full-Stack & Cloud Systems

I build backend systems, APIs, and full-stack applications with Python, FastAPI, React, and AWS.

Currently working on: Contributing to open-source (Deepiri) and building data systems for churn prediction.

ResumeGitHubLinkedInContact

What I Do

Engineering That Ships and Stays Reliable

Fast scan view of where I spend my time and where I add the most value.

  • Backend APIs and data systems
  • Full-stack application development
  • Cloud deployment and debugging
  • Production-style problem solving

Featured Projects

Real Systems and Production-Style Engineering

Each project highlights a concrete problem, implementation choices, stack, and delivery tradeoffs.

ChurnLab

Flagship data + backend system for churn prediction experimentation

  • Python
  • FastAPI
  • Pandas
  • scikit-learn
  • PostgreSQL
  • Docker
  • AWS
Problem
Retention teams need fast, testable signals for which customers are likely to churn, but raw event data is noisy and difficult to operationalize.
Solution
Built a backend-driven analysis platform that ingests customer-behavior data, engineers features, and exposes prediction and reporting endpoints for downstream tools.
What I Did
Designed API contracts, implemented feature-generation workflows, and integrated model output into a usable service layer for product-facing decisions.
Challenges
Balanced model iteration speed with data quality guarantees and built repeatable validation checks to avoid silent training regressions.

Independent Study: TabDiff

Research-backed engineering for synthetic tabular data generation

  • Python
  • NumPy
  • Pandas
  • Jupyter
  • scikit-learn
Problem
Real datasets can be sparse or constrained, making it hard to run safe, repeatable churn experiments at scale.
Solution
Implemented and tested a TabDiff-inspired workflow to generate synthetic tabular records and benchmarked downstream prediction behavior against baseline datasets.
What I Did
Framed the experiment design, implemented preprocessing and evaluation scripts, and documented tradeoffs between fidelity and utility.
Challenges
Controlled for data leakage risk while keeping synthetic outputs statistically meaningful enough for practical experimentation.

Deepiri (Open Source)

Production-minded collaboration in a real team codebase

  • Python
  • FastAPI
  • Docker
  • GitHub Actions
  • Linux
Problem
Open-source platforms need reliable backend and infrastructure improvements that support active contributors and real users.
Solution
Contributed backend and deployment-facing updates that improved maintainability and made development workflows smoother for contributors.
What I Did
Delivered scoped fixes and enhancements through PRs, coordinated with maintainers, and adapted implementation details based on review feedback.
Challenges
Worked within existing architecture constraints and maintained backward compatibility while improving core behavior.

Rubik's Cube Solver Project

Team-based system design and algorithmic problem solving

  • Java
  • Data Structures
  • Unit Testing
  • Git
Problem
The challenge was to translate cube-solving logic into a clear, testable software architecture that team members could build on in parallel.
Solution
Built a modular solver implementation with predictable state transitions, move validation, and collaboration-friendly code boundaries.
What I Did
Owned critical logic paths, improved solver correctness with test cases, and helped align architecture decisions across teammates.
Challenges
Debugging edge-case move sequences required systematic state inspection and careful handling of orientation rules.

Backend Service API

Production-style CRUD and service orchestration backend

  • FastAPI
  • PostgreSQL
  • Docker
  • AWS
  • REST
Problem
Many internal tools need stable APIs with clear contracts, validation, and observability, not just quick demo endpoints.
Solution
Built a service-oriented API with authentication, structured error handling, and deployment-ready configuration for staging and production.
What I Did
Implemented endpoint logic, schema validation, and health/diagnostic endpoints to support reliable operations.
Challenges
Designed for backwards-compatible API evolution while improving performance on heavier query paths.

Hugging Face Deployments

Live Deployments

Active Spaces that are currently deployed and accessible.

churnlab_frontend

Docker-based Space for the ChurnLab frontend deployment.

Open Space

churnlab

Docker-based Space for the ChurnLab backend/service deployment.

Open Space

Skills

Clean Stack Overview

Organized by the tools and domains I use in real project work.

Languages

  • Python
  • Java
  • C++
  • JavaScript
  • TypeScript
  • C#

Backend

  • FastAPI
  • Flask
  • Node.js
  • REST APIs

Frontend

  • React
  • Next.js
  • HTML
  • CSS

Cloud / DevOps

  • AWS
  • Docker
  • Linux
  • Git

Data / ML

  • Pandas
  • NumPy
  • scikit-learn

Experience

Recent Work

Hands-on engineering across backend systems, reliability debugging, and open-source collaboration.

2025 - 2026

Systems Evaluator

Outlier AI

  • Evaluated model and software-system behavior using structured, repeatable testing workflows.
  • Investigated pipeline failures, reproduced edge cases, and documented root causes for faster remediation.
  • Delivered reliability-focused analysis that improved release confidence for downstream stakeholders.

2025 - Present

R&D Contributor

Deepiri (Open Source)

  • Contributed backend and DevOps improvements in an active open-source codebase.
  • Worked through issues and PR review loops with maintainers to ship stable, maintainable changes.
  • Improved deployment reliability and developer ergonomics through practical engineering refinements.

Currently Building

Active Right Now

This section keeps the portfolio alive and shows current momentum.

  • Contributing to Deepiri open-source engineering work
  • Running a churn prediction study using synthetic data
  • Preparing for AWS Cloud Practitioner certification

Debugging Philosophy

I approach bugs by isolating variables, analyzing logs, reproducing issues, and validating fixes systematically.

Engineering Notes

  • Debugging API race conditions under concurrent traffic
  • Designing reliable retry + idempotency patterns for background jobs
  • Translating model experiments into production-ready service boundaries

Resume

Download a one-page summary of experience, projects, and technical stack.

Download Resume

Contact

Let's Build Something Useful

If you're hiring or building, I can contribute quickly on backend APIs, full-stack delivery, and production debugging.

Availability

Actively open to interviews, contract work, and full-time software engineering roles.

Typical response time: within 24 hours.

Collaboration Fit

  • Open to backend, API, and full-stack engineering opportunities
  • Comfortable joining existing teams and ramping quickly on production codebases
  • Best fit: projects that value reliability, ownership, and clear communication
EmailLinkedInGitHub