A child of Myspace, in the early(ish) days of the web I was designing Myspace themes and websites for bands and musicians that I knew. I got into C# and ASP.NET back in the early 2000s at my first tech job working at a small company. While there I discovered Ruby on Rails and subsequently made a career working on Rails apps for the most part over the next decade.

I’m a fast learner and always interested in new ways of doing things, as a result I’ve kept up with the progression of the modern frontend Javascript frameworks (Angular & React, Vue, Elm etc) and built several commercial products using them.

During my career I’ve worked with a broad range of technologies, in a range of different industries in various capacities (From junior backend, to frontend architect to CTO). Ask me about backend persistence, remote async working styles, object oriented programming, functional programming and immutable state or UX design and I’ll probably have an opinion. My editor of choice for the past ten years is Vim, the best text editor there is!

Commercial Experience

Contractor & Cofounder from Sep, 2020 to Present

My role has mainly been focussed around designing and implementing the frontend architecture (cannot claim the theme design though) of the Farmgod management app, aka Braiins OS Manager, but it has also involved designing backend and devops processes for Block21 Gmbh, who partnered with Braiins in 2020 in a joint venture to build a cloud based farm management solution for cryptocurrency mining. The primary frontend tech we use is VueJS with flux based state management.


Building the frontend application from scratch with Vue JS.

Based on an earlier prototype written in PHP I rewrote the frontend as a pure single page application written in Vue JS.

Developed complex wizards and forms in Vue with unit and e2e tests The ability to create farms and configure them is a key part of the product, crypto mining is in many ways complex and hence the forms required are also complex. Managing side effects and validation state caused by form submissions in such forms is tricky. That's where forward only state (like Vuex) is really handy.
Containerizing the frontend Using multi step docker container to get a highly optimized image build.
Designing the CI pipeline Using my past experience with CI, I designed the CI workflow to enable rapid delivery of multiple variations of the product.
Aggregating high volumes of data with stored procedures I designed and implemented a pure SQL stored proc program to enable agreggation of high volumes of statistical data. Ask me about windowing functions!
Optimising the Python backend for high volume realtime streaming I refactored postgres schema and async processes in python to enable high volume queue draining of live stats.
Remote Working Since b21 are based in Europe, I've carried out the entire job remotely, with daily standup meetings conducted online.


  • Docker
  • SPA development with Vuejs
  • Frontend TDD
  • Frontend Architecture
  • Gitlab & Git
  • Interviewing candidates
  • Mentoring developers
  • Coding Python
  • Coding Stored Procedures
Consultant CTO from Aug, 2020 to Jan, 2021

I joined as a part time technical advisor a few months after development had begun and took on the role of CTO designing the backend architecture and conducting multi stage interviews of candidates for the tech team.


Organising the tech team Interviewing and hiring engineers, designing the async workflow as the team was in multiple time zones (UK, Autralia, Indonesia). Configuring the infrastructure for contractor access.
Directing the architecture I worked extensively with the Edo, one of the two original co founders to realise the product design from a systems perspective and then convert that into tangible work for the team.
Microservice development Built several microservices using Express (JS) to manage outbound calls to 3rd party APIS and incoming async webhooks.
Designing and implementing the loan management system. This involved collaborating with various team members to extend the basic architecture and integrate 3rd party API's for handling repayments.
Designing and implementing CI system in Google Cloud (Cloud Run) Built the CI deploying Angular using Cloud Build and Cloud Run and various other Cloud Compute infrastructure challenges.


  • Systems Architecture
  • Google Cloud Platform
  • Jira
  • Webflow
  • Angular 9
  • Slack
  • SQL Server
  • Firebase
  • Github
  • Continuous Integration
  • 3rd Party Integrations
  • Open Banking
  • Payments APIs
Contractor then Employee from Oct, 2019 to Jul, 2020

I joined as a senior Ruby contractor and went full time as the CTO designing and implementing the greenfields architecture, interviewing candidates and organising the tech team.


Organising the tech team Interviewing and hiring engineers, designing the async workflow as the team was in multiple time zones.
Directing the architecture I worked extensively with the product manager Alan Lin to design the platform that would allow customers to sign up and connect open banking and numerous other payment providers such as Stripe, Paypal and GoCardless, so that we could do realtime risk assesments of their business and offer competitive variable cap loans.
Designing async systems One of the primary challenges for Outfund was to integrate open banking in order to do realtime analysis of client financial data. Using a combination of OAuh and Ruby based background workers I designed and implemented the prototype and then built the team to build out based on that architecture.


  • Systems Architecture
  • Webflow
  • Gatsby
  • Slack Integration
  • Rails Development
  • Test Driven Development
  • Github
  • Heroku Platform
  • Continuous Integration
  • 3rd Party Integrations
  • Open Banking
  • Event sourcing with RailsEventStore

I joined as a senior Ruby contractor building out Lavanda’s short letting property platform in Ruby on Rails. Also worked with the Angular 4 based frontend. Solving load optimisation problems and calendaring integration problems.


Writing geo location optimisations in Ruby There were several slow endpoints and page loads that needed performance improvements that I solved by optimising data reads using Active Record's query syntax
Writing and documenting the REST API Documenting and refactoring the API using Postman to test, liasing with the lead frontend developer for requirements.
Pairing with and mentoring the team I paired with and advised junior team members to improve their knowledge of Ruby and web development skills with Rails. Used Sandi Metz book: Practical Object Oriented Programming With Ruby as a basis for some of this work.
Reviewing code Conducting code review to ensure that high quality code with proper test coverage was being written
Third party calendar integration Paired with another team member to deliver a highly requested calendar integration with data provided with by a partner, involved writing complex logic in Ruby that would handle syncronising the calendar.


  • Ruby On Rails
  • Angular JS
  • Test Driven Development
  • Github
  • Heroku Platform
  • Continuous Integration
  • 3rd Party Integrations

When I joined there was very little automation in place, in the face of growing demand. First off, I was tasked with developing an automated labelling system that would generate a custom label with pack house and delivery instructions. Next task was building the payments API.


Developing an inhouse labelling system that would print a PDF label from a web interface. Built in Rails the labelling system would talk to an external shipping API to determine if a shipping slot was available and print batches of labels to order.
Payments API Built using Graphiti and Rails with Test Unit as the test framework.


  • Rails development
  • 3rd Party API Integrations
  • Git & Github
  • Heroku

Working with existing Rails apps and their extensive gem architecture and widget system. Implemented a number of solutions during my contract.


Upgraded the gem management system Upgraded the gem management system from a legacy one ( Jeweller ) to using the de facto standard - Bundler - across 30+ gems for future maintainability.
Working with Rails apps Solving day to day problems and implementing features in their production apps
Legacy code extraction Refactoring and extraction of sub optimal code to improve the codebase.
Containerized apps with docker Utilized docker to containerize apps for improved portability and security, this was complicated by the fact that there are multiple services and a legacy gem architecture to factor into the container architecture.


  • Rails
  • Bundler
  • Git
  • Docker

Working with the existing app from version one, we built the React app from scratch for version two on top of an API that was simultaneously being developed by us in Ruby. While there I was introduced to the flux way of building reactive applications, using Redux for state management in the frontend.


Developing complex flows and forms in React Implementing a board pack overview, detail page and interactive notes and comments in React.
High level of frontend testing We were meticulous about testing the redux actions, reducers and side effects with jasmine and mocha.
Developing the Rails JSON API Using jsonapi-resources gem to develop a standards compliant jsonapi to feed the React frontend
Working in an agile team Working in sprints with regular planning meetings and stakeholder interaction


  • SPA development with React
  • Frontend TDD with Jasmine & Mocha
  • Git & Github
  • Pair programming
  • Ruby on Rails

I implemented a WCAG 2.0 standards solution for one of their client applications.


Accessability for screen readers Implemented markup changes, aria tags and tested with screen readers to meet WCAG 2.0 standards.


  • Rails
  • aria tags
  • WCAG 2.0

I started my contracting business in 2014 working with a broad range of mostly London based tech companies, from fintech to food delivery.


Directing a small company

Duties include contracting, invoicing, bookkeeping, promotion and research & developing open source tools.

Writing software and consulting for clients

Duties include web dev, backend, mentoring, building tech teams and systems architecture


  • I.T contracting
  • coding
  • web design
  • team management
  • invoicing
  • book keeping
  • promotion
  • market research
  • open source development

Funding Circle is a peer to peer finance application. My role was focussed around the development and maintenance of Funding Circle’s online platform.


Agile workflow This was my first real exposure to agile methodologies on a large scale. We began working scrum style, we looked at tooling like mingle, but that process continually evolved and moved away from scrum and ultimately we used physical boards and cards.
Implementing the continuous integration Implemented Jenkins CI on a local linux machine. We decided quite early on on a git merge strategy that would best suit us all and enable multiple features to be developed in parallel.
Scaling backend reports. Extracted existing HTML & CSV reports that were naively implemented and not scalable, rewrote them in Ruby using cron based periodic tasks to defer the generation of large datasets. Designed an OO interface that would allow different legacy reports to be ported quickly to this architecture.
Rebuilding the sign up. Worked in a small team using Cucumber & RSpec to drive features. We took the existing Symfony app and rewrote the sign up forms using Rails. We implemented shared sessions by exposing the Symfony session to Rails via a json endpoint. We used the client_side_validations gem to quickly generate model based validations for forms. We redirected urls using a combination of url rewrites ( Nginx ) and PHP Symfony filters in order to integrate the Rails code into the existing Symfony app. Styled using Bootstrap CSS framework.
Implementing the new stylesheet. On the landing page and on numerous stock pages. Used CSS and image maps.
Implementing the secondary market as a service. Implemented an Active Model based presenter for searching loan parts, using jQuery based ajax and Haml templates, fed by a series of JSON API calls. Modified API endpoints and worked with Ruby based Elasticsearch integration code to modify filters. Later implemented the OAuth client code for this service.
Refactoring the two part credit check. Lots of domain logic had been leaked into the controller, we extracted it out into domain objects ( hexagonal style ) through bdd with RSpec and Cucumber.
Scaling the sell page. I used a hybrid of Rails and its Active Record query interface to break out and scale legacy endpoints that were collapsing under load and also to implement search and pagination ( Kaminari ) for the same feature. I then integrated it into the existing Symfony page ( to avoid a grand rewrite ) using a combination of jQuery driven ajax rendering haml templates, and url rewrites ( Nginx ) redirecting to the masquerading Rails actions.
Working with the API. The API was based on Ruby/Rack API dsl mounted in Rails in conjunction with a decorator library and templating dsl to build the API. I have worked at various times on this part of the architecture adding endpoints and modifying existing ones to address scale problems.
Modifying the loan book summary. Built up a library of Ruby code using PORO, RSpec and some metaprogramming - over the results generated by a complex stored proc - to aggregate the data into a summary view. This feature depended heavily on complex untested legacy stored procedures that took several hours to generate their report data, but time constraints meant we could not port them to Ruby, so I used RSpec to generate ‘data signatures’ for the generative stored procedure and then tested permutations of that against the Ruby code as integration tests. Deprecated the old summary stored proc and shipped it.
Rewriting the broker application flow. We used an AngularJS frontend that would gracefully degrade to an HTML only series of forms, driven by a Rails app, driven by an API ( SOA ), this project was put on hold while higher priority problems were addressed, I believe an evolution of it is currently being developed.
Implementing whole loans. Broad surface area of effect. Touched on many parts of the system. We used a combination of: Modification of existing stored procedures, modifications to various services, modifications to the admin backend: Using domain objects, feeding into Rails, feeding into embedded iframes inside existing legacy Symfony templates. Created new API endpoints to facilitate the sale of whole loans.
Porting loans to the new SOA. We used raw SQL scripting and Postgres import/export capabilities to export data structures to a new schema ( doing this in Ruby would have proved prohibitively slow ). We then developed a data comparison reporting tool in Ruby to check the consistency and integrity between the two schemas. We used the adapter pattern and repository pattern to facilitate switching existing features to new service. This project is ongoing.
Mentoring During my time at Funding Circle I mentored many new developers on the architecture of the app ( and how to get it up and running in development ) and on development techniques such as BDD with RSpec and the usage of the Vim editor.
Maintaining the symfony app. Used a lot of unix command line, Vim & regular expressions to manage the legacy codebase.


  • Ruby On Rails
  • PHP Symfony
  • Agile Methodologies
  • Git
  • Jenkins
  • Linux

Sideprojects & Open Source

I’ve contributed to some active open source projects in the past but I’ve also written some of my own open source packages, mostly in Ruby but some in Javascript.

Most of this I wrote for fun or because it scratched a particular itch that I couldn’t find an existing package for.

Some of the more recent ones are ….

Vorm Validations
I wrote this npm package while working on a VueJS app, it’s for mapping backend errors into forms

Jekyll Webpack
I wrote this Ruby Gem to enable easy use of webpack with jekyll

I wrote this Ruby Gem to make defining search filters in web applications much easier

Check my Github for other open source contributions