Olena Nevel

Also known as: Lena

Senior Software Engineer · Full-Stack Developer & Product Thinker

I deliver more shipped projects than any other engineer on my team. Expert in complex integrations (Stripe, Twilio, TriZetto) with product-minded execution. Consistently rated "Exceeds Expectations" for delivering above-scope work and tackling the hardest challenges.

GitHub Activity
5+ Years Experience
10+ Major Features Shipped
100% Sprint Completion Rate

Selected Experience

Barti — Senior Software Engineer (P3)

2025–Present · Remote · Exceeds Expectations Rating

  • Promoted from P2 to Senior with Exceeds Expectations rating for consistently delivering above-scope work.
  • Delivered more shipped projects than any other engineer on the team — consistently completes sprints fully ahead of schedule.
  • Led development of Insurance & ID Scanning, Multi-location Services & Inventory, VOIP Voicemail/Transfer — directly improving product adoption across multiple client practices.
  • Authored and rolled out new PRD format, bridging engineering and product management, improving cross-team clarity and reducing scope creep.
  • Mentored junior engineers through code reviews, pair programming; launched Barti Book Club with 15+ participants.

"Tenacious in completing work within estimated timelines; ensures bug fixes and customer issues are fully resolved."

Performance Review, H1 2025
40% Scope creep reduction
#1 Team velocity

Barti — Software Engineer

2023–2025 · Remote

  • Delivered 10+ production features: TriZetto claims integration, VOIP Message Center, Intake Automation, Dosespot e-prescribe integration.
  • Stripe payments integration completed in just 2 weeks — delivered Caller ID, Imaging, Elavon payment terminal.
  • Known for tackling the hardest technical challenges that others couldn't solve; operates with complete autonomy and requires no hand-holding.
  • Reduced backlog timelines through proactive dependency management.
80% Payment setup time reduction
3-4 Weeks saved per sprint

Health Note — Full-Stack Engineer

2021–2023 · Remote

  • Co-built Clinical Builder, a flagship product that let non-technical content teams configure provider note templates.
  • Delivered configurable Screener module and dynamic patient Q&A PDFs that streamlined pre-visit patient intake.
  • Owned several ambiguous, zero-to-one projects, driving them from idea through architecture, implementation, and production launch.
  • Built reputation as the "go-to" engineer for hard or underspecified problems.

"Recognized as the go-to engineer for ambiguous and underspecified problems."

Performance Review, Health Note, 2022
100+ Healthcare providers served
1000+ Monthly assessments processed

Health Note — Data Scientist

2020–2021 · Remote

  • Designed and deployed a real-time analytics dashboard giving leadership insight into product usage and patient workflows.
  • Built and maintained ETL pipelines to Redshift; operated Superset BI dashboards supporting business decision-making.
  • Generated insights into feature adoption and revenue impact, directly informing product strategy.
50K+ Daily events processed
$2M+ Strategic decisions influenced
Earlier Roles
  • Indeed — Country Manager (SEO/SEM, localization, analytics) · 2018–2020
  • Research Specialist — Model implementation & data analysis (MATLAB/FORTRAN)
  • Esthetician — Client care, precision, operations (transferable soft skills)
"She has been and I believe will remain one of top contributors at Barti and to date has shipped more projects than any other engineer on the team."
Director of Engineering · Barti Performance Review

Case Studies

Real impact, measurable results

Trackly — Personal Issue Tracker

Live Demo: coming soon

Product Thinking Full-Stack 0→1 Product

Context

Most issue trackers (Jira, Linear, etc.) are built for teams and heavy workflows. Freelance devs and small teams need something lighter: simple task creation, quick prioritization, and visibility without bloat. Nothing in the market fit that need.

Product Thinking & PRD Workflow

  • Introduced PRD-based task structure (Why / What / How / Acceptance Criteria) → ensured every feature tied back to value
  • Designed "Spin Up a Task" modal flow to avoid context-switching; validated through personal dev workflow testing
  • Added rationale tracking for "Won't Do" tasks, turning backlog rejections into documented decisions
  • Prioritized developer joy: double-click to create tasks, inline editing, and modal-based detail views

Architecture & Tech Choices

  • Frontend: Next.js + plain CSS → lean, performant, easily themeable
  • Backend: Flask (MVP) → Django migration (ORM scalability, built-in admin, future extensibility)
  • Validation: Pydantic for strict I/O contracts
  • Design Decision: Migration justified by need for stronger data integrity + built-in tooling as features expanded

Metrics & Outcomes

  • Shipped MVP in <6 weeks while working full-time
  • Reduced task creation time by 70% vs. traditional Jira/Trello workflows
  • Documented 30+ tasks during real-world development of Trackly itself
  • Designed for scaling to PM & Ops use cases (validated with real conversations in Marketing/Sales workflows)
70% Faster task creation
30+ Tasks documented
Solo Developer & PM

⚡ Stripe Integration (2 Weeks) — Barti

Speed & Precision Revenue Impact
Challenge: Barti needed end-to-end credit card payments live ASAP to support clinics. Timeline: 2 weeks.

Action

  • Integrated Stripe Checkout + Terminal from scratch
  • Delivered Lightbox payments + hardware terminal support with full PCI compliance
  • Coordinated with frontend to ensure seamless patient-facing UI
Result: Shipped in 14 days (including QA + production rollout). Enabled clinic customers to collect payments immediately, unlocking new revenue. Recognized internally as proof that "complex integrations don't need to drag on."
14 Days to ship
PCI Compliant

⚡ TriZetto Claims Integration — Barti

Healthcare APIs Complex Integration
Challenge: Healthcare practices needed automated insurance claims processing. TriZetto's legacy API was complex and poorly documented.

Action

  • Reverse-engineered TriZetto API through trial and documentation gaps
  • Built robust error handling for network timeouts and API failures
  • Implemented claim status tracking and automated retry logic
Result: Automated claims processing for 50+ healthcare practices. Reduced manual claim submission time by 85%. Became the go-to engineer for "impossible" third-party integrations.
85% Time reduction
50+ Practices served

🏥 Clinical Builder — Health Note

Collaboration Zero-to-One Product
Challenge: Content team needed a way to configure provider note templates without engineering support. No clear product requirements existed.

Action

  • Partnered directly with founder + content team to shape vague needs into a product roadmap
  • Built Clinical Builder, a no-code tool for configuring note templates
  • Architected UI/UX to support non-technical users while ensuring data integrity
Result: Adopted by 100+ providers for daily use. Reduced dependency on engineers for template changes by 80%. Became a flagship product demo used to close new clients.
100+ Daily users
80% Dependency reduction

📞 VOIP Message Center — Barti

Twilio Integration Real-time Systems
Challenge: Healthcare practices needed voicemail management, call transfers, and caller ID integration with their existing patient management system.

Action

  • Integrated Twilio Voice API for call handling and voicemail transcription
  • Built real-time call transfer system with patient context
  • Implemented caller ID lookup with patient record matching
Result: Deployed across 30+ practices. Reduced call handling time by 60%. Improved patient experience with contextual call transfers and voicemail-to-text.
60% Faster call handling
30+ Practices deployed

Featured Project

Trackly — Personal Issue Tracker

Lightweight, product-minded issue tracking for solo devs and small teams

Live Demo: coming soon

Built with speed and clarity in mind. Features modal-based task creation, PRD-friendly fields (why/what/how/acceptance criteria), and clean read/write flows that actually get used.

Technical Stack

  • Frontend: Next.js with plain CSS — sticky header, reusable layout components
  • Backend: Flask → Django migration (better ORM, admin interface, scaling)
  • Validation: Pydantic for robust I/O validation and API contracts

Key Features

  • Authentication & user management
  • Task CRUD with notes, due dates, priorities
  • Kanban board with drag-and-drop
  • Double-click task creation for speed
  • "Won't-Do" rationale tracking
Last Commit Top Language Repo Size Code Style Type Checking
View Code Live Demo (Coming Soon)

Code Quality Showcase

Real code from production systems

Task API Validation

Pydantic Type Safety API Design

Production-ready Pydantic models for Trackly's task management API. Shows type safety, validation, and clean API design patterns.

# Trackly Task Validation Models
from pydantic import BaseModel, Field, validator
from datetime import datetime
from typing import Optional, Literal
from enum import Enum

class TaskPriority(str, Enum):
    LOW = "low"
    MEDIUM = "medium" 
    HIGH = "high"
    CRITICAL = "critical"

class TaskStatus(str, Enum):
    TODO = "todo"
    IN_PROGRESS = "in_progress"
    DONE = "done"
    WONT_DO = "wont_do"

class TaskCreateRequest(BaseModel):
    title: str = Field(..., min_length=1, max_length=200)
    description: Optional[str] = Field(None, max_length=2000)
    priority: TaskPriority = TaskPriority.MEDIUM
    due_date: Optional[datetime] = None
    
    # PRD-style fields for product thinking
    why: Optional[str] = Field(None, description="Why is this needed?")
    what: Optional[str] = Field(None, description="What exactly are we building?")
    how: Optional[str] = Field(None, description="How will we implement this?")
    acceptance_criteria: Optional[str] = Field(None, description="How do we know it's done?")
    
    @validator('due_date')
    def due_date_must_be_future(cls, v):
        if v and v <= datetime.now():
            raise ValueError('Due date must be in the future')
        return v
    
    @validator('title')
    def title_must_not_be_empty(cls, v):
        if not v or not v.strip():
            raise ValueError('Title cannot be empty')
        return v.strip()

class TaskResponse(BaseModel):
    id: int
    title: str
    status: TaskStatus
    priority: TaskPriority
    created_at: datetime
    updated_at: datetime
    due_date: Optional[datetime]
    
    # Track rationale for decisions
    wont_do_reason: Optional[str] = None
    
    class Config:
        orm_mode = True  # Enable ORM integration
View Backend Code

Recent Activity

Latest public commits (private work not shown)

  • Loading recent commits...

View Full GitHub Profile

Technical Skills & Practices

Frontend

React Next.js JavaScript/TypeScript HTML5/CSS3 Responsive Design

Backend

Python Flask Django Node.js SQLAlchemy REST APIs

Cloud & Database

AWS Lambda MongoDB PostgreSQL Redshift ETL Pipelines

Integrations

Stripe Twilio TriZetto Dosespot Elavon

Product & Leadership

PRD Writing Backlog Management Code Reviews Mentoring Cross-team Collaboration

Development Practices

Test-Driven Development CI/CD Pipelines Performance Optimization Architecture Design

Let's Connect

Looking for a senior engineer who delivers? Let's talk about how I can help your team ship faster and solve harder problems.

LinkedIn

Professional network

GitHub

Code & contributions

Send Your Calendly

Share your meeting link directly

Human Verification Required

To access resume files and email, please confirm you are a human. This helps prevent automated scraping.

Resume Options