Drew Cooper Email & Phone Number

• Determined that poor CI/CD infra and lack of unit testing were the main problems initially and got agreement about priorities
• Did part of a several-step migration of sources. CI, and deployments, including:o Self-hosted Bitbucket to Github (with Jira, Slack, etc. integrations)o Self-hosted Bamboo to Github Actionso Migrating from several.
• Worked with infra dev and area stakeholders to determine how to standardize the way we build/host services
• Convinced the infra dev to set up Hashicorp Vault for us so to migrate secrets out of the repos I’m playing with. (And roll the keys, of course!)
• Started driving us toward an evidence-based view of our security (data flow diagrams, threat modeling) instead of 3rd party ”security monitoring” whack-a-mole
• Added Puppet tests searching for conflicts in our network configs

• Defined what needed to be tested and how and got buy-in
• That last bullet point involved a lot of docs and tech talks and changing cultural language around tests in addition to hands on work on automation
• Helped drive future architecture, from UML diagrams to descriptions of services needed to all of the personal convincing to make simpler, more consistent systems to selling it to management and product as needed and.
• Via coaching, tool creation, and hands-on work, helped a team of PhD physicists learn to gradually become software developers: how to code better than grad students, how to collaborate on code, how to interact with the.
• Cypress tests for FE, Go test for BE (goc for multi-service integration coverage), perf with K6, et al.

• Drove lots of organizing. Engineering basics like what meetings to attach to iterations, what’s expected at a standup, what the SDLC looks like from planning to post-deploy, et al.
• Got Cypress tests running on Concourse CI on every commit with many workarounds (like calling Puppeteer to log in and get auth token because at the time, Auth0 integration was not straightforward)
• Flutter driver testing on mobileo Found a way to get access to internal state to speed up/stabilize driver integration tests
• Attempted to focus engineering on security through advocacy and things like threat modeling
• Hired another tester and smoothed the way for her

• Set up CI for an exotic project involving Linux Docker containers, Packer builds of Windows VM images, mix of Jenkins Configuration as Code, job DSL, and pipeline script, several strange tricks with Azure, and more to.
• Wrote an injecting proxy for the MQTT protocol
• Automated initial integration tests over MQTT (see above) because there were no APIs
• Determined how to write automation against our Unity client via REST API driven by Python code
• Drove architectural decisions like transport message standardization and common controls and monitoring for service state to help integration test efforts

Redmond, Washington, United States

• Talked with all stakeholders to determine automation goals
• Wrote C++ async I/O web server and RESTful interface into game client to create API to drive game plus OO Python framework with goodies like screenshotting
• Wrote initial tests for game entity stability
• Created render performance tool that relied on data but hid the math from designers (“look at this map – the long fingers are pointing at problems!”)
• Attempted to set up makeshift test lab – no budget
• Fixed the fixable BVTs and made them part of the build

• Created web automation framework, building on Selenium, wrote tests in it, and got other developers to start using ito RUTL (https://github.com/drewcoo/rutl) is my attempt to recapture and build on some of these ideas
• Added iOS/Android support to framework, building on Appium, wrote initial test cases in it (RUTL will expand to include this next)
• Helped get web and backend codebases doing continuous deployment
• Standardized automated build workflows, examples:o Built on GitHub pull request for all reposo Ported all builds to Jenkins rather than several different systems
• Created automated performance suite with Ruby-JMeter for a backend service (and as proof of concept for other perf tests to come)
• Helped all of the other developers stabilize both their production and their test code

• Standardized test plans across the company
• Wrote and open-sourced Jenkins plugin to integrate our CI jobs with our chosen test case management system (TestRail) (update: plugin code removed now)
• Wrote and evangelized fake server framework and developers tole me loved that they could live-debug previously difficult-to-reach, multi-service edge cases on their desktops at willo the basis for Doppelserver.
• Standardized, simplified, and improved code quality of test code on my team
• Evangelized test practices and organized a cross-team “test guild”
• Wrote and maintained integration tests and performance benchmarks for all of the services my team owned

• Hired and led a team of 6 testers, tightly embedded in dev teams and involved in the entire product cycle from ideation through post-release
• Developed and oversaw automated testing of a web app (Selenium + JMeter + custom code), mobile apps on iPhone (tried several frameworks and didn’t like any) and Android (Robotium), and back end APIs (custom framework)
• Developed techniques to test video rendering and playback, wrapping humans in an API and predicting performance of the humans - I still think that was a potential side business
• Set up and maintained our continuous integration (Jenkins) server
• Integrated deployments (Chef + Capistrano), continuous integration, bug tracking (FogBugz), source control (git/GitHub + a little SVN), et al. with reporting/alerting/dashboard feedback (largely custom)
• Organized and contributed to tech talks and bug bashes; created a culture that cared about testing

• Designed/drove primarily manual testing of a web app, an iPhone app and an Outlook plugin
• Set up and maintained our test lab in the cloud (SkyTap; mix of Linux servers and Windows clients)
• Led a team of 1-2 others as the team grew
• Developed a testing methodology for our manual testing that coupled the strength of exploratory testing with planning/logging on our internal wiki, code coverage results for a test session and developer involvement
• Wrote client-side(browser) performance test to monitor changes from release to release
• Deployed/maintained continuous integration servers (Hudson) for our different platforms (Linux and Windows and was working on OSX) and integrated them with our source control system (hosted Git)

• Started a series of test/engineering brown bag talkso Not only did this share knowledge, but it also helped the team transitions after WhitePages acquired Snapvine
• Helped WhitePages’ testers fit into Agile teams
• Shipped an iPhone application, ensuring not only a useful, reliable app but also ongoing monitoring and crash reporting to ensure ongoing quality measurements
• Continued to monitor/support existing Snapvine services and ensure that as some of them were tombstoned customers were alerted and remaining features kept working
• Created a framework for testing an internal language-agnostic RPC mechanism that included auto-generated command line tools for a given IDL (for easy repros) and a unique approach to a combinatoric engineo This was.
• Led efforts toward getting continuous integration servers running after every check-in

• Made testing an integral part of Snapvine’s culture
• Led/mentored two other testers
• Created/ran manual and automated (mostly Ruby) tests for all parts of Snapvine, including its Flash apps and telephony back end
• Wrote automated test suite for an in-house database sharding solution involving Ruby, MySQL, and Memcached
• Wrote automation to compare different storage solutions when used with our usage patterns
• Organized bug bashes, which were even more necessary than usual because of the difficulty of automating most end-to-end user scenarios (wrinkles: Flash and telephony)

• Created/ran manual tests
• Created the test plan that became the de facto spec for the entire product
• Automated use of the product embedded in Office apps via their COM interfaces (used VBScript)
• Set up/maintained the FogBugs bug tracker and integrated it with Subversion
• Created release/branching strategy and created automated builds – worked toward automated build/BVT process
• Helped guide future development to make the product both better for users and easier to test

• Wrote and maintained test plans and test code (mostly C++ and a little C#, Perl, VBScript), primarily for API-level testing, but also tools and UI testing as needed
• Debugged both test and dev code, mostly user mode but also have kernel and managed code debugging experience
• Understand software release cycles. Shipped every core version of Windows from Windows 2000 SP1 and also worked on Vista and Visual Studio 2005
• Helped in design phase of both dev and test work - clean, testable designs
• Focused strongly on customer satisfaction - as a tester, I consider myself the greatest advocate of the customer
• Strong security background: Spent my entire time at Microsoft in Windows Core Security, working primarily on EFS (Encrypting File System) and code signing (Authenticode)