Hello, my name is Mark and I work @BuzzFeed as a Staff Software Engineer (formerly Principal Engineer @BBCNews).

I’m also a published author with Apress and LeanPub:




“as smart as developers are, they are not always good at explaining things in a way that makes human sense. not you. you are an exception. you are A+”

I ❤️ this feedback. It’s music to my ears, and is what I strive for: to help others to do their best work and to push/promote the good work other engineers do (especially those from either a diverse background or minority).


You can find me online at the following locations:


BuzzFeed (June 2016 - present)

The journey has just begun…

BBC (Jan 2013 - June 2016)

I joined BBC News as a client-side/mobile specialist within their Core News team. Within the year I had moved into a senior engineering role. The (then) Technical Lead for the BBC News Frameworks team requested I join them in order to help the organisation transition from its current platform over to one built upon the AWS platform.

I started in the Frameworks team building and designing back-end architecture for different microservices hosted upon the AWS platform, and we developed these services primarily using JRuby. In October 2014, I was offered the role of Technical Lead.

Near the end of 2015 I decided to change roles to Principal Software Engineer, as my previous role required more of my time to be spent in meetings and handling line manager duties, where as I wanted to focus my time more on helping my team solve technical problems.

Storm Creative (Feb 2001 - Dec 2012)

I started working at the agency Storm Creative straight out of college. I was always focused on learning and improving my skill set - both technical and communication skills - the latter helped me communicate better with both clients and other stakeholders/colleagues.

I progressed upwards through the organisation, moving from initially being a client-side web developer (this included doing animations utilising ActionScript 3.0) to becoming a server-side developer (ASP.NET, PHP and Ruby), then onto becoming a Technical Lead across all projects and finally becoming the Digital Media Manager responsible for my own team of four engineers and overseeing all aspects of our projects.

Key Achievements


  • Saved BuzzFeed $60k annually during Hack Week working on a project that replaced NGINX+ (an expensive commercial product) with its open-source equivalent (see my presentation slides here).
  • Designed and co-implemented new authentication system built in Python on top of AWS Cognito. The aim was to replace the authentication logic currently present within our legacy monolithic web application, and also to be the foundation for authentication and authorization requirements for our modern micro services moving forward.
  • Built a Python package that wraps scrypt. Motivation was to provide a consistent interface that allowed engineers across the organization to utilize approved security functions for hashing and encrypting data.
  • Started to introduce both Kim Scott’s “Radical Candor” and Fred Kofman’s “integral communication” concepts to enable teams to work more openly and honestly.
  • Introduced Wednesday lunch videos/presentations. The idea being to have multiple teams in the UK office have lunch together while watching a video (or someone giving a presentation) and thus having a topic to focus discussion around. This was primarily done for fun, but also to help us to better engage with each other and to encourage people to share things of interest to them (it didn’t have to be technical videos/presentations, but anything that was felt to be interesting).
  • Designed and implemented a Python package which acted as a Tornado web handler decorator for acquiring/caching/revalidating an asymmetrical public key (provided by the authentication reverse proxy we built in Go - see below bullet). The key is used to verify the signature (message integrity) attached to a JWT containing public user data. Its purpose was to help engineers to quickly integrate with our custom built authentication service and provide a consistent experience across the platform.
  • Co-designed/engineered an authentication service layer reverse proxy (written in Go). Utilised JWT’s (signed using public-key cryptography) to ensure upstream protected services could trust the received user data and its integrity.
  • Selected to be part of a new infrastructure team tasked with designing a new ‘authentication and authorization’ service layer(s).
  • Promoted to Staff Software Engineer in January.


  • Created basic README validator as part of our Better Docs initiative and in preparation for our Doc Day event.
  • Took lead on documenting and improving the state of our monitoring by way of implementing best practices (see my article for details) as well as improving the quality (and consistency) of our operational runbooks (see an example template).
  • Core member of the BuzzFeed “Better-Docs” Working Group. We aim to improve documentation and its discoverability for BuzzFeed Tech. We primarily intend to do this through the standardization of doc formats, the creation and maintenance of doc tooling, and continuing education of ourselves and the BF Tech community about documentation.
  • Tech Lead for the Site Infra ‘Resilience’ team. This includes designing a disaster recovery strategy by the name of “Plan Z” with handling of multiple failure scenarios and failovers across many service providers.
  • For the 2017 Hack Week I built an operations Slackbot tool in Go called OpsBot. It would dynamically create standardized incident channels and would automatically invite relevant users to the incident channel (using an emoji ‘message reaction’ convention). It also allowed searching for runbooks via the Google Drive API. Future updates will include creating a post-mortem Google Doc and inviting all users inside the incident channel to view the newly created doc.
  • Implemented nginx solution (with integration tests) to round-robin requests for static assets between multiple cloud providers, as well as to ensure in the face of an outage that we failover appropriately to one of the other functioning providers for complete static asset resiliency and robustness.
  • Technical Lead and architect for a new dynamic video player service to enable an asynchronous editor workflow along with a flexible architecture for providing the most appropriate video for our users.
  • Consolidated two separate cli tools into one go-fastly-cli: General purpose CLI tool for interacting with the Fastly CDN service via its REST API
  • Redesigned one of our Python packages, which initially was a facade providing a multi-tiered cache abstraction around a single HTTP client. Requirements determined that the consumer should provide one of a list of accepted HTTP clients and so I utilised an adapter pattern internally in order to provide a unified interface for the provided HTTP client dependency.
  • Built a Python Auto Generated API Documentation tool that builds upon Git pre-commit hooks and utilises Make and Bash
  • Throughout the year I’ve found the need to build different tools to help me do my job more efficiently: Ero: Local/Remote CLI Diffing Tool written in Go, Lataa: Fastly VCL uploader/activation CLI tool written in Go, Carbon: CLI HTTP Headers Filtering Tool written in Go which was superseded by a Bash equivalent as well as a Vim plugin for MyPy: a Python static type checker
  • Worked on the CDN layer’s VCL logic and spent time investigating and building abstractions to make working with VCL easier (such as a logging abstraction along with a quick on/off toggle)
  • Presented an engineering workshop on the Site Router service (see last year) to all engineers within BuzzFeed
  • Lead the development across a mostly US based team and rollout of new critical service responsible for serving the responsive BuzzFeed home page


  • Migrated Fastly’s version of varnish/vcl 2.x to standard 4.1 (working with one of the Site Reliability Engineers) for use as a backup CDN in case of extreme failure scenarios that required us to switch providers quickly and who do not have the features that Fastly provides as part of their modified version of Varnish
  • As part of a mono repo that stores multiple sub-services (each with their own team/squad) I designed and implemented a generic Pull Request template file to be used across the organisation for that repository. It stemmed from this blog post I wrote “GitHub Pull Request Formatting” back before GitHub provided an automated feature (although based on specific feedback it didn’t end up exactly the same as described there)
  • Co-ordinated use of gpg-agent inside our infrastructure teams VM tooling
  • Built a microservice using a Python scheduler for automatically executing integration/smokes tests periodically to ensure there are no regressions with the new BuzzFeed nginx router and its core behaviours (deployed via AWS’s ECS ‘Container Service’)
  • Worked with the lead engineer on a safe and measured (monitoring handled by Datadog) global rollout of our new routing service by utilising an incremental regional deployment process (controlled by Varnish and GeoIP lookups) and working closely with the relevant QA teams
  • Architect and author of a fundamental new routing service (Site Router), responsible for taking logic out from the Fastly CDN/Varnish configuration and proxying specific requests onto upstream services via nginx - helping to decouple services from the CDN layer. I also designed a YAML based config driven API on top of nginx and helped translate and update the relevant CDN/Varnish logic.
  • Developed multiple reusable Python scripts, such as a timing decorator that posted runtime metrics to StatsD/Datadog
  • Helped porting over old Perl based monolithic web app into separate BFF microservices built with Python and deployed via AWS ECS
  • Encouraged and implemented use of additional Python linters to catch common issues within BuzzFeed services and APIs
  • Started working for BuzzFeed as a Senior Software Engineer, to become part of and build up the core UK team
  • Defined “The Perfect Developer Qualities” and refined the values based on open community discussions
  • Released two new open-source projects:
  • Strong focus on DevOps: writing shell scripts whilst in charge of creating and configuring multiple AWS accounts for development/production environments
  • Tasked with load testing, analysing, identifying and fixing performance and scaling issues within the BBC’s “Mozart” platform
  • I built a simple, yet performant, open-source URL monitoring system in Bash called Bash Watchtower
  • Tasked with leading the BBC News coding and architecture ‘best practices’ working group
  • Co-author/architect of the BBC’s “Mozart” platform
    • Page composition microservice platform
    • AWS microservices built with Ruby and Go


  • Published guest article “Building Software with Make” for popular online resource Smashing Magazine
  • Represented BBC at the AWS re:Invent week-long technical conference in Las Vegas
  • Co-author/architect for a Go based cli tool called “Apollo”, which abstracted away cert based access to an internal REST API and allowed teams to more easily deploy services to the AWS platform
  • Released open-source program (written in Go) called “go-requester”, which is a HTTP service that accepts a collection of “components”, fans-out requests & returns aggregated content
  • Published the book “Programming in Clojure
  • Worked closely with multiple members of my team (over the course of the year) with the goal of getting them ready for their next round of promotions
  • Developed event archiving service using Go and AWS Lambda
  • BBC News Frameworks team won the “Connecting the News” category at BBC Hack Day
  • BBC Newsbeat v2 was released (this was the first fully AWS product from BBC News)
  • Co-author/architect for a BBC AWS-based monitoring solution
  • Published guest article “Designing for Simplicity” for popular Mozilla engineer David Walsh
  • Tech Lead for the General Elections (Feb - May 2015)
  • Released open-source Clojure version of the Spurious Ruby AWS SDK Helper to enable Clojure developers to utilise fake AWS resources locally
  • Rebuilt and migrated BBC’s Market Data to AWS using the BBC’s open-source Alephant framework, of which I was a co-author (Nov 2014 - Feb 2015)


  • Jello (internal synchronisation service between Trello and Jira)
  • Won “Most innovative use of Technology” BBC News Award (Docker CI)
  • Won “Best Public Relations of the Year” BBC News Award (Pro Vim)
  • Became Technical Lead for the BBC News Frameworks team (October 2014)
  • Senior developer part of the BBC’s Scottish Referendum offering (June - September 2014)
  • Senior developer part of the BBC’s Vote 2014 Elections offering (Jan - May 2014)
  • Co-author/architect for the open-source Alephant framework
  • Co-author/architect of a cloud based distributed load test tool (built around JMeter)
  • Arranged public BBC presentation with Sandi Metz “Object-Oriented Design”


Tools, Languages and Tech

I don’t profess mastery, but I’m adept with most of the below, and I have an aptitude towards learning what I need to get the job done right:


  • Site Router (Video): 80 minute presentation on BuzzFeed HTTP routing service abstraction.

  • BBC Talks (Slides): various presentations I gave while at the BBC.

  • Imager.js (Slides): Talk I gave at the Mozilla offices in Paris (which included speakers from: Google, Apple, Microsoft, Adobe, Opera, W3C and Akamai).



I’m a print published and self-published author; I’m also a tech reviewer and am a published author for many popular online organisations (you’ll find many technical articles on my own website as well):



  • Tech Reviewer Grunt Cookbook (May 2014)
  • Tech Reviewer “Troubleshooting Docker” (May 2015)


NET Magazine

Smashing Magazine


BuzzFeed Tech

  • I wrote a three part series on BuzzFeed’s core HTTP routing service (built upon NGINX+) called “Scalable Request Handling: An Odyssey”:


The following links are to some of my more ‘popular’ articles. My main focus when writing is to take a complicated or confusing topic and attempt to distil it, in order for the subject to be more easily understood.


Note: listed alphabetically

  • BBC Alephant:
    The Alephant framework is a collection of isolated Ruby gems, which interconnect to offer powerful message passing functionality built up around the “Broker” pattern.

  • BBC Imager.js:
    Responsive images while we wait for srcset to finish cooking

  • Bash Headers:
    CLI tool, written in Bash script, for sorting and filtering HTTP Response Headers

  • DOMReady:
    Cross browser ‘DOM ready’ function

  • Go ElastiCache:
    Thin abstraction over the Memcache client package gomemcache allowing it to support AWS ElastiCache cluster nodes

  • Go Fastly CLI:
    CLI tool, built in Go, for interacting with the Fastly API

  • Go Find Root:
    Locate the root directory of a project using Git via the command line

  • Go Requester:
    HTTP service that accepts a collection of “components”, fans-out requests and returns aggregated content

  • Go Reverse Proxy:
    A configuration-driven reverse proxy written in Go (no dependencies outside of the standard library).

  • Grunt Boilerplate:
    Original Grunt Boilerplate

  • Image Slider:
    HTML5 Canvas Game

  • MVCP:
    MVC + ‘Presenter’ pattern in Ruby

  • Sinderella:
    Ruby gem for transforming data object for specified time frame

  • Spurious Clojure AWS SDK Helper:
    Helper for configuring the AWS SDK to use Spurious

  • Squirrel:
    PhantomJS script to automate Application Cache manifest file generation

  • Stark:
    Node Build Script for serving HTML components


I ideally want to get across two fundamental things about me:

  1. I’m very passionate about programming and the openness of the web
  2. I love getting the chance to learn and experience new things