David Burton

I build systems that learn from data.

From algorithmic trading to Alzheimer's research — wherever data has weight, I build the system.

// projects

Atlas Trading System

ML ensemble manages real capital in live markets. Event-driven trading system with machine learning ensemble models that predict market movement and execute trades autonomously. Trained on 2.48 million data points with walk-forward validation.

2.48M training data points

[ Clinical Research ]

Cognitive Health Study

130K longitudinal observations, one question about aging. Large-scale biostatistics study investigating medication effects on cognitive decline in 30,000+ older adults. Uses survival analysis and propensity score matching. Under peer review.

130K+ longitudinal observations

Atlas Trading System

Event-driven algorithmic trading system running live on SPY options with real capital. An ensemble of ML models — XGBoost for directional prediction, TensorFlow for pattern recognition, a custom risk model — evaluates market conditions every second and executes trades autonomously. Walk-forward validation across 2.48M data points ensures the system generalizes to live market conditions, not just historical patterns. The system doesn't care that it's 3 AM.

2.48Mtraining data points

99.5%system uptime

Livetrading status

def calculate_microstructure_features(self, market_data):
    """Calculate market microstructure indicators"""
    features = {
        'bid_ask_spread': self.calculate_spread(market_data),
        'order_imbalance': self.calculate_imbalance(market_data),
        'price_impact': self.estimate_impact(market_data),
        'volume_profile': self.analyze_volume(market_data)
    }
    return features

Python XGBoost TensorFlow Redis Docker

Cognitive Health Study

Independent biostatistics research using the NACC dataset — 130,000+ longitudinal observations across 37 Alzheimer's Disease Research Centers. The study investigates whether a common medication class affects the rate of cognitive decline in older adults. Methodology: survival analysis with time-varying covariates, propensity score matching to control for selection bias, mixed-effects models for longitudinal outcomes. Nobody assigned this. The question was interesting.

130K+longitudinal observations

37research centers

Peer Reviewstatus

class PropensityAnalysis:
    def calculate_scores(self, data):
        """Propensity scores via logistic regression"""
        X = data[self.covariates]
        y = data[self.treatment]

        model = LogisticRegression(max_iter=1000)
        model.fit(X, y)

        return model.predict_proba(X)[:, 1]

Python SciPy Statsmodels Jupyter Pandas

[Data Engineering]

Lead Generation Engine

Automated intelligence pipeline behind a $30M sales year.

Python GCP spaCy

Complete

[Agentic AI]

Grant Writing Agent

NLP system that reverse-engineers winning proposals.

Python Transformers FastAPI

Complete

[ML Systems]

Email Automation Platform

Behavior-driven email engine sending 100K messages per hour.

Python Celery Redis

Complete

[ML Systems]

Adaptive Learning Engine

Real-time ML adapts difficulty as learners progress.

Python TensorFlow Redis

Complete

Lead Generation Engine

Built for BTL Industries' sales team. Scrapes Google Business Profiles, extracts decision-maker contacts using NLP and OCR, and pipes enriched leads directly to the CRM. The team using it won President's Club 2023 and doubled the second-place team's revenue — $30M total team revenue that year.

$30Mteam revenue

50%more qualified leads

class ParallelScraper:
    def __init__(self, max_workers=5):
        self.executor = ThreadPoolExecutor(
            max_workers=max_workers
        )
        self.driver_pool = queue.Queue()

    def scrape_company(self, company_url):
        driver = self.driver_pool.get()
        try:
            driver.get(company_url)
            return extracted_data
        finally:
            self.driver_pool.put(driver)

Python GCP Selenium spaCy MongoDB

Grant Writing Agent

Analyzes successful grant applications to extract structural patterns — section ordering, keyword density, sentiment arc, readability targets — then generates new proposal sections that match funder expectations. Tracks 10,000+ funding sources and matches organizations using semantic similarity. Cut proposal prep time by 60%.

60%faster proposal prep

10K+funding sources tracked

def extract_successful_patterns(self, winning_proposals):
    """Identify patterns in successful grants"""
    patterns = {
        'structure': self.analyze_structure(winning_proposals),
        'keywords': self.extract_keywords(winning_proposals),
        'sentiment': self.analyze_sentiment(winning_proposals),
        'readability': self.calculate_readability(winning_proposals)
    }
    return patterns

Python spaCy Transformers FastAPI PostgreSQL

Email Automation Platform

Full-stack email platform with behavior-based triggers, A/B testing with chi-squared significance checks, and ML-powered personalization. Processes 100K+ emails per hour with 98% inbox deliverability. Integrates bidirectionally with CRM systems. Statistical rigor baked into the marketing layer — the system doesn't declare a test winner until p < 0.05.

100K+emails per hour

98%inbox deliverability

def calculate_winner(self, test_id):
    """Statistical significance testing"""
    data = self.results[test_id]
    chi2, p_value, dof, expected = chi2_contingency(data)

    if p_value < 0.05:
        return self.identify_winner(data)
    return None  # No significant winner yet

Python Celery Redis PostgreSQL SendGrid

Adaptive Learning Engine

Adaptive education platform using deep knowledge tracing and Bayesian models to predict mastery and adjust content in real time. Serves personalized learning paths to 10,000+ concurrent users with sub-100ms recommendation latency. The system watches how each learner responds and updates its model of their ability continuously — Item Response Theory meets production ML.

40%higher completion rates

10K+concurrent users

def calculate_mastery_level(self, responses):
    """Skill mastery via Item Response Theory"""
    # Bayesian estimation of ability parameter
    theta = self.estimate_ability(responses)
    # Adaptive threshold based on learning curve
    threshold = self.get_adaptive_threshold(theta)
    return {
        'mastery': theta >= threshold,
        'score': float(theta),
        'gaps': self.detect_knowledge_gaps(theta)
    }

Python TensorFlow Scikit-learn Redis Docker

// experience

Math teacher turned data scientist. Purdue BA, Indiana M.S. Ed, Google Cloud Professional Data Engineer. The full story is in the PDF.

Download Resume

Writings

Building Atlas: Production ML at Scale

Deploying a forecasting system with real capital on the line — model selection, monitoring, and what breaks in production.

Replacing DuckDB: 10x with Rust

Building a custom time-series query engine with predicate pushdown that outperformed DuckDB by an order of magnitude.

ML Deployment: Prototype to Production

The gap between a working notebook and a production system — monitoring, versioning, and the infrastructure nobody talks about.

Data Viz with WebAssembly & Rust

Interactive visualizations compiled to WASM — near-native performance in the browser for datasets that would choke JavaScript.

All writings

Contact

Get in touch

Based in New York City. Open to data science, quantitative, and research roles.

david@databurton.com GitHub LinkedIn Resume