§ Experience

At Disney, I act as technical lead and architect of the Native Client Platform (NCP) Core engine, the native runtime behind the Disney+, Hulu, and ESPN applications on millions of living-room devices: PlayStation 4 and 5, Xbox, Amazon Vega, and hundreds of set-top boxes and smart TVs (by chipset and model). The goal is a portable, efficient, and correct cross-platform runtime for all three apps. NCP was announced publicly in Introducing the Disney+ Application Development Kit (September 2021).

• Architecture: led the design of the engine across every class of device, from Linux set-top boxes to game consoles, including an extensions system that doesn't require complex linker scripts, a memory allocation strategy spanning traditional Linux (malloc) to consoles (no malloc), background workers for Wasm (like Web Workers), and signature checks for Wasm bundles; managed the OS abstraction layer implemented by set-top box partners
• Rust & WebAssembly: designed and implemented an in-house Wasm engine that separates compilation from execution, reducing app startup time; built a versioned FFI layer to manage ABI compatibility so newer APIs work with the older native runtimes already on devices; contributed fixes (internally) to open-source Wasm interpreters (binary-format decoding, call-stack access for panic handling); made the engine a first-class Rust project, built through Cargo, with APIs migrated from raw C bindings to idiomatic Rust
• Platform evolution: designed and built a system for caching and comparing low-level rendering commands, unlocking the performance needed to ship on low-end set-top boxes; designed a system that adds JavaScript to the platform, with a low-latency event system connecting the device's operating-system events to the JavaScript event loop, and a rendering system, written in Rust, that implements a lightweight Canvas for JavaScript
• Continuous Integration: prepared the team for AI-assisted coding by adding support to CI (minimum test coverage, static code analysis, LLVM sanitizers, code-ownership rules, merge queues); built a cross-platform C unit-testing framework for mocking functions at compile time

At SpotHero, a parking reservation app, I was a full-stack engineer on the Consumer team, working primarily in TypeScript/JavaScript (React) and Python (Django).

• Marketing: acted as lead for all engineering needs that intersected with the Marketing team, serving internal users (marketers running campaigns) and external ones (customers redeeming promotional codes)
• Web performance: focused on server-side rendering for the consumer website, so every page arrives as finished HTML: faster loads for users and better indexing for search engines; routed searches to the site's many vanity URLs, matching locations to points of interest so a search like /search?lat=X&lng=Y becomes a specific page like /point-of-interest-parking

At Arity, a mobility data and analytics company founded by Allstate, I was the engineering lead for the Shared Mobility team, which leveraged Arity's big data and machine-learning models into B2B2C products for the ride/car/bike sharing space: REST APIs for companies and web applications for their users. One product was based on a "prequalification score" that rated prospective users from details about them.

• Leadership: mentored and organized the team's engineers and collaborated with product managers and designers
• Recognition: received Allstate's 2019 Reach For The Stars award for excellence in engineering, given to one or two people from each Allstate business unit (one of two from Arity) and presented at an all-expenses-paid ceremony in Las Vegas
• Security: designed and implemented a field-level encryption library/protocol used to securely store personal information such as names and addresses (AES-GCM); architected the user authentication/authorization system for Arity web products (OAuth, JWT)

At Spot Trading, a Chicago-based options trading firm, I was a member of the Core team, which developed and maintained the central trading platform for the firm.

• Trading platform: designed and implemented adapters for consuming low-latency multicast news feeds from Dow Jones & Bloomberg; extended and patched the existing core trading platforms (C++)
• Rust: created an analysis platform in Rust, outside the live trading path, parsing and indexing millions of messages decoded from recorded network traffic (PCAP) and presenting them through a web UI; as Rust was new to the team, I designed the complete Rust workflow, from toolchain setup to style guidelines
• Build & tooling: integrated the Google Benchmark framework to verify performance down to nanoseconds; ported the Makefile-based build system to Bazel, improving build times and maintainability

In this division, I was part of the team responsible for designing and developing components of the IMO (Information Management Onboard) system in the Airbus A350, in particular its networked (IP) routing components.

This was a set of systems built on embedded Linux using C++. Built under intense time pressure, the product had become unstable, and as the schedule slipped, my team was formed to redesign and refine the system, and regain confidence in the project.

• Redesign: redesigned and implemented components and services to improve stability and performance while decreasing complexity: concurrency primitives and threading architecture, the system logging platform (syslog), the central messaging system between planes and ground units, and the service that periodically checked the firewall's rules, restored them if they had been tampered with, and applied network-configuration changes
• Simulation: built a simulation environment that ran the platform's components on developer machines, decoupling software testing from system hardware
• Build & tooling: created a simplified build system (CMake & Ninja) that dramatically reduced build times; set up continuous integration (Jenkins), with unit testing (gtest), code coverage (gcov), and daily static code analysis (Coverity); built an automatically generated documentation/status website for the team

On the ARINC-661 Graphics Server team, I implemented and certified the graphical components (widgets) for an embedded ARINC-661 graphics library (C++). These components run on cockpit displays, so they were subject to DO-178B certification, which demands rigorous verification of every requirement. I also created a Ruby DSL test framework to ease and improve software verification.

§ Education

A Preliminary Study of Fixed Flaky Tests in Rust Projects on GitHub (FTW 2025 at ICSE), with Minh Phan and Yang Chen

Summa cum laude

§ Projects

Open-source software at github.com/jtomschroeder:

• cedar: functional-reactive GUI library for Rust
• crystalline: algorithms & data structures for the Crystal programming language
• lambda: C++ library for functional programming

§ Skills