MerkleX is a VC funded crypto currency trading platform that offers high performance non custodial exchanges for ERC-20 tokens on the ethereum network. Currently we're in beta, with an invite only period.

My role at MerkleX is to develop platform features using a broad range of technologies. Recently I implemented an invite referral management system which required me to add several endpoints and handlers to our Java Api. I added SQL functions to cut down on the number of queries made from the Java Api to our database. Additionally, I implemented the frontend components and pages to allow users to generate invite codes and redeem them with React, Redux and SCSS.

Codelitt Incubator

Codelitt is a product incubator providing agile services to corporations. We would collaboratively iterate on ideas and products with clients, from design to launch.

While at Codelitt I primarily worked with frontend technologies, specifically React, Redux and Flexbox. After being there for a year I was promoted into a position where I would help plan and organize tasks for my team members, mentor junior team members, take client calls to explain technical details and plan sprint items, and also take lead on any large features. These large features would require me to build a plan in markdown with phases, subtasks, estimates and architecture decisions which I would then present to our CTO and then integrate his feedback into my changes. I really began to love frontend tech during this position.


Auvenir is a Deloitte backed platform that provides small to medium sized auditing firms technology to better plan, manage and collaborate on audits. We leveraged cloud based technologies and machine learning to better inform auditors of all the details that their clients provided.

While at Auvenir I worked on a Node.js + WebSockets backend with vanilla JavaScript on the frontend. I built various parts of the platform including document and user dashboards as well as a Node.js based configuration tool for docker that allowed our devops team members to easily and securely inject environment variables into our containers.

Department of National Defence

Strong, Secure, Engaged: The Canadian Department of Nation Defence keeps us strong at home, secure in North America, and engaged in the world.

While at the D.N.D I worked on an in house facebook clone based on the ELGG PHP framework. I worked on improving the overall codebase, fixing bugs, and also leveraged plugin based architecture to add onto existing functionality.


Sick Fits

Sick fits is a GraphQL based shopping application that leverages React + Apollo on the frontend and node + prisma + yoga on the backend. I built this project while taking Wes Bos' Full Stack Advanced React & GraphQL course. I learned a lot about the ins and outs of GraphQL while working through this course. I learned about how to make and define queries, integrated those returned data sets into your store and components and then how to appropriately test those components. Here are the links to the frontend and backend code I built while following along.

React DND ND

React DND ND is a drag and drop written in ES6 and React without any additional external dependencies. Currently one of the biggest security concerns for JavaScript apps is dependencies within our dependencies. At MerkleX, our code is audited by the governing boards within the U.S. finance sector, which is why I began to prototype this drag and drop. We needed something we can trust, and this drag and drop has served as the basis and will support additional functionality as required. Check it out on Github.

Python UUID generator web service

This python web service exposes a single endpoint that that returns UUID. It was my first stab at getting into docker and python back in 2016. I learned a lot about containerization and the benefits of using it. Now docker is part of my daily workflow! Check it out on Github.

Blog Api Browser

For the last couple of years I've been working hard at developing my frontend skillset. I wrote a blog api browser not because I needed it, but because I wanted to try out some cool tech I had read about online. This api browser features an immutable data store via ImmutibleJS, async await, and React hooks. I'm super excited for hooks and async await to become the norm in js development! Check it out on Github.

YAR - Yet another router

YAR is a router written in vanilla PHP. When I started out doing full stack development, more often than not I was using a framework or set of libraries that would handle routing for me. Later on I became curious as to how the magic happened, so I went ahead and wrote a router! As it turns out, a router can be pretty simple. Essentially my implementation reads the browser URL, checks the request verb, and pulls any body and / or url data, and then forwards the data to the appropriate handler, all of which is done by reading PHP's global variables pertaining to the request data I needed. Check it out on Github.

Renew self signed certs

I wrote a little node script to regenerate self signed SSL certificates so that I wouldn't have to do it myself. Leveraging shell.js and node-schedule I was able to make a bot that would handle this for me on a yearly basis, which I would deploy along side my apps. I no longer use this as let's encrypt + certbot have solved this in a better way, but it was still a fun little project. Check it out on Github.

HapiJS Server Scaffold

My hapi server scaffold project is boiler plate code built on top of hapi.js + Node.js to be used in any given project. It features JWT authentication, user management, basic architecture layout, cors + db + server configuration utilities and defaults, and a number of other helpful functions to get development started quickly. One of the biggest lessons I learned when coming back to the project after a year had passed is that scaffolds are only valuable if you maintain them, and in order to maintain them they must provide value. Going forward I would tend to use frameworks provided by the open source community instead of building my own. However, this was still a great opportunity to learn about architecture, api's and authentication. Check it out on Github.



I love JavaScript. I really do. Seriously. It is my go to language for just about any task these days. It can be used on the frontend, backend and system level (with the appropriate packages). I've been writing JS since ES5 and have grown to love it more and more as newer iterations of the language have come out. EcmaScript 6, 7 and 8 deliver game changing features, such as class syntax, const and let, async await, the null coalescing operator and optional chaining; All of which make huge impacts on code quality and dev happiness. All of my past positions have required a heavy use of JS often with React or Node. A course I would recommend to someone new in the JS space and functional paradigm would be Zsolt Nagy's Deep Dive into Functional JavaScript. I took it early on while at Codelitt and it massively improved my ability to read and write performant JS.


TypeScript is my second language of choice and by far my favourite MicroSoft tool (right up there with VSCode). Being able to define data types for your function arguments and return types help eliminate an entire class of bugs along with helping developers think through their code with more care. I'm also a big fan of interfaces in TypeScript as they can replace the need for prop-types in react and also allow a team of 10+ developers have code defined information of the data flow within your application rather than relying on potentially outdated docs or communication. One final reason I love TypeScript is because it comes configured out of the box with the latest and greatest EcmaScript features.


React is by far my favourite technology to work with. I find it to be a pleasure to write and with the vast amount of online resources from courses to blog posts to the phenomenal React docs, it has become my go to for frontend projects. Two of my go to sources for react knowledge are Wes Bos' courses and Dan Abramov's blog.

At Codelitt my entire role was frontend based. I learned all about the React component lifecycle, frontend routing, writing SCSS based modules and how to effectively fetch data from a rest api and store it in redux. I also did quite a bit of component testing with Jest and Enzyme.

While MerkleX is more of a full stack role, I still work with React almost daily. I applied many of the same skills as I did at Codelitt but with a slightly different set of tooling and a more holistic approach to writing features.


Redux is the defacto state management system when dealing with React. At both Codelitt and MerkleX I leveraged Redux to store and provide data to our applications components. In those positions I learned a lot about how to configure redux, layout stores and leverage middleware to help increase application performance. A personal favourite middleware of mine is Thunk. Thunk allows you to have async actions so that you can fetch data from your Api's without blocking your frontend. I also often use the RSK (Redux Starter Kit) which comes with several helpful configurations, tooling and middleware (including thunk) to have a more performant store and an easier to work with code base.


GraphQL is one of the most exciting technologies available to developers today. It allows us to write more concise code, only requesting the exact data we need, rather than pulling in an entire resource like you would in a Rest Api. React + Apollo is a solid choice for getting started on the frontend. I learned quite a bit about it while taking Wes Bos' Full Stack Advanced React & GraphQL course. Here's the frontend and backend code for the course project entitled "Sick Fits".

Styling and Layout

Between Codelitt and MerkleX I've worked with a lot of different approaches to styling apps. I've worked with css and scss based modules, styled-components, flexbox, break points with custom styling and several smaller facets of css. When I first got into frontend development I really hated styling; None of it was consistent across browsers, the units rarely felt like they made sense and building responsive layouts was a nightmare. Of course, this was pre-flexbox and before I really knew about pre-processors. These days I'm happy to write styling, the tools have come a long way and I've learned about how massive the impact a solid UX can make on user happiness.


I have done a lot of node based projects over the years from building bots for MerkleX to doing full stack JS development at Auvenir. Node has been a constant in my career and it's by far my favourite backend technology. Node is an interesting project given that it runs off of chromes V8 JS engine, but lives outside of the browser. The unique challenge of having it live outside the browser is that it has no access to browser api's which results in the node team needing to re-implement core functionality such as timers. setTimeout in node is essentially a wrapper around a C function that handles keeping track of the timers.


SQL is a tried-and-true technology that has been around since before I was born and will be around for long after I'm gone. In school I took 3 SQL courses which taught beginner, intermediate and advanced topics. Relational databased are massively powerful in terms of storing, connecting and interacting with your data. At MerkleX I've written a lot of CRUD queries, table definitions and table updates to support new functionality in the site such as the invite and referral management system. I also spent quite a bit of time packaging multiple queries in a single handler from our backend into one cohesive SQL function. The SQL function's I wrote included looping, defining variables, querying other tables and throwing errors where appropriate which would then be handled in the Java Api.

NoSQL / Document DB's

NoSQL / Document DB's are relatively new in the dev space. I first studied them in school while taking a full stack node.js course and then worked with MongoDB professionally while working at Auvenir as a full stack JS dev. I found Mongo to be very easy to work with, despite its heavy use of callbacks at the time. I find document DB's are great for iterating on ideas and working with smaller data sets. However, I still prefer SQL for larger app's given the ability to define relationships between tables in a more natural way.


Docker is a technology that allows you setup your systems architecture in a scalable and immutable way. Both MerkleX and Codelitt leveraged docker for hosting their apps. A common docker composition I worked with was three tiered, where we'd have one container for the frontend, one for the backend, and one of the DB. These containers would be integrated together via docker-compose and could be deployed on any platform that provided a VM or had native support for docker. I worked with building my own images and compositions a while ago which you can see on my github and dockerhub accounts linked in the side bar.

Automated Testing

Writing unit and integration tests has been an important part of work experiences. While working at Auvenir we used mocha and chai for unit testing our node based backend, which was my first real introduction to writing tests with my code. At Codelitt pretty much every feature I wrote or changed required new / updated tests. At Codelitt we used Jest and Enzyme which was really interesting to learn about as before this position I didn't know much about frontend testing. At MerkleX we use JUnit and Spectrum to test our Rest Api. In many ways JUnit has set a standard for testing tools across the industry and personally I enjoy using it.