I design, build, and support key product features, perform technical design reviews, develop and drive consensus on the patterns and practices for developing backend code, and prioritize/drive projects to improve our backend architecture and cross-cutting functionality.

Feature projects I worked on:

Notification Backend - designed and implemented an event bus-driven backend service that powers notifications to customers of detected wildfires via email and SMS. Includes a rules engine for determining which customers are notified about which detections based on subscription preferences, jurisdictions of interest, and seasonality.

External API - designed and implemented a RESTful API and webhook framework for partners to access Pano AI's cameras and be notified about detected fires.

Automated Deployments - automated all backend services' deployment to the production environment. This took a formerly 1-2 hour manual and error-prone process that required downtime to a fully-automated, zero-downtime process that finishes within 15 minutes.

Open Telemetry - integrated OpenTelemetry into all backend services for metrics and tracing. The telemetry data collected now drives automated alerting and has been instrumental in debugging.

Technologies: Java, Postgres, PostGIS, Google Cloud Pub/Sub, Google Cloud Storage, AWS SES, Twilio, OpenTelemetry

Throughout my time at ActiveState I built out backend microservices to support the launch and expansion of the ActiveState Platform. The platform is a cloud-based, self-service build system for open source language distributions. Customers select which language and libraries they want and the build system produces an installable binary containing the runtimes of the requested language and libraries (plus their full dependency graphs).

Major projects I worked on:

Componentized Builds - I designed and implemented a new version of our build orchestration microservice. I converted it from a monolithic build process that built every component one-at-a-time from scratch to a componentized build which built from the bottom of the dependency graph up and parallelized component builds wherever possible. It also cached component build results for use in subsequent builds. This cut the build time of fresh builds down by more than half and made builds containing previously cached components nearly instantaneous.

Technologies: Golang, Python, Postgres, Kafka, GraphQL, Swagger, Mesos, Docker, Kubernetes, Bazel

Auto-Remediator - I mentored our intern as he built a microservice to automatically remediate build failures. Through design, planning, implementation, testing, and deployment, I guided his work by pointing him to relevant prior art and providing feedback on his deliverables. By the end of the project, he had implemented to spec a working prototype microservice that could detect and remediate two common build error cases. He also established clear code patterns for extending to service in the future to handle additional build error cases.

Technologies: Python, Postgres, Kafka, Docker, Kubernetes, Bazel

Some earlier ActiveState Platform projects I worked on:

Inventory API - I co-designed and co-implemented a RESTful API for cataloging the languages and libraries the platform could build. A key design requirement was being able to add to and update the catalog without altering already-requested builds. To support this, we stored mutations as new “revisions” in the database rather than overwriting old data. The API then allowed requests to specify a timestamp in order to see API resources at a prior revision. This design enabled catalog updates while also keeping builds reproducible.

Technologies: Golang, Postgres, Swagger, Docker, Kubernetes, Bazel

Solver - I designed and implemented our first dependency solver API. It took in a customer’s build requirements–the language and libraries they wanted–and gave back a “build plan” which detailed all the components needing to be built and the build dependencies between them, utilizing the catalog data in Inventory API. This solver was part of the core functionality of the ActiveState Platform.

Technologies: Golang, Postgres, GraphQL, Swagger, Docker, Kubernetes, Bazel

I took on numerous projects and roles during my time at Quizlet as the company grew from 17 to 80 people:

Data team - one of two data engineers responsible for operating and maintaining our data pipelines, improving the quality and reliability of our data, and building an ML-backed realtime labeling service.

Technologies: Python, Airflow, BigQuery, RabbitMQ, Google Cloud Datastore

Backend team - lead project to begin breaking up Quizlet's PHP monolith into a service-oriented architecture. We first planned out and prototyped the new architecture and then, once we validated the design suited our needs, we built our first service: payments and subscriptions.

Technologies: Java, Vert.x, gRPC, Gradle, Recurly, Docker, Kubernetes

Core/growth team - lead project to make Quizlet’s annual paid subscriptions auto-renewing. We replaced part of our homegrown subscriptions backend with Recurly and updated our analytics pipelines to pull in Recurly transactional data.

Technologies: PHP, Python, Recurly, Stripe, PayPal, Amazon Payments

Internationalization team - co-lead project to internationalize the Quizlet website and mobile apps. We planned out and built all the technical components needed to launch in another locale, including both the online components for serving up localized content and the offline components for managing the translation workflow. We launched our first locales on-time and our work allowed Quizlet to expand to a current total of 18 locales.

Technologies: Python, PHP, JavaScript, Smartling, Webpack, Gulp, Sublime Plugins, FormatJS

Platform/infrastructure team - key contributor on project to move Quizlet’s entire

infrastructure from Joyent to Google Cloud, which involved rewriting almost all of our Puppet machine configuration and developer tooling to work with the new cloud provider. We finished this 7-month project on time and the cutover was incident-free.

Technologies: Puppet, Python, Golang, GCP, MySQL, CentOS, PHP, Consul, Memcached, Bash, Ruby

My marquee project was designing, developing, and rolling out an internal Platform as a Service. It ran as a service container into which other engineering teams deployed their own RESTful services. It allowed developers focus their coding on business logic while the container took care of all cross-cutting service concerns. The project encompassed the platform runtime as well as a suite of Java APIs, tooling, documentation, and code samples for platform service developers.

The main pieces I built were:

• A DSL that service developers used to describe the data model, validation rules, and access patterns of each RESTful resource within their service

• An algorithm which validated API request input against the data model/validation rules laid out in the DSL

• An externalization layer that mapped resources’ access patterns to RESTful API endpoints and handles (de)serialization

• A fluent Java API used within service implementations for making cross-service requests, implemented using a dynamic proxy

• A Java API for accessing configuration properties that supported variable replacement and reload on value change

• A suite of gradle build scripts which validated, packaged for deployment, and generated client libraries for services

• A metrics integration which automatically captured request rate, error rate, and latency for requests into all services

Beyond developing the platform, I was responsible for meeting with the backend engineering teams to understand their needs and gather requirements for new platform features as well as diving into and debugging service problems, both during development and in production.

Technologies: Java, Java EE, OSGi, Gradle, Jackson, Jersey, Spring, Tomcat, Cassandra, ZooKeeper