How I learned a language and launched a product in 60 days
Tags: elixir, startup, showdev, react
Published: 2021-01-12 00:25:23

### Background: Why I had to pivot

Almost 3 years ago I incorporated Kinesis Inc, the corporate entity behind [Xkit](https://xkit.co). But at the time I was building a non-custodial cryptocurrency exchange. After going through Y Combinator and raising $3.5M from some great investors and building a product I was really proud of, I made the hard decision to [shut it down](https://sparkswap.com) nearly a year ago. We hadn't found an audience that would provide venture scale growth, so it was back to the drawing board.

I started working on an idea in FinTech, trying to help a friend's company solve a problem with SMB customers not paying on time (or at all) for their services. As I talked to prospective customers about the problem, one thing became abundantly clear: in the time that I had spent away from the SaaS world toiling in the Bitcoin mines, expectations around how SaaS tools work together had radically shifted. It was no longer a "bonus" that you worked with some of their other tools, it was an outright necessity. For the product I was exploring I would be building integrations with Quickbooks, Xero, Stripe, and a few others.

I asked around if anyone had any good tools to accelerate this process, but the responses I got back were pretty disappointing. Nearly every tool was focused on *consumers* of SaaS software plugging together the services that they used. Not nearly as much was out there for *producers* of SaaS software trying to build native integrations to the other tools their customers use. Not only that, but the ones that did exist tried to pretend that we live in a world where powerful integrations are easy to design and maintain with a GUI. While I'm a fan of no-code and low-code solutions, the fact remains that for some tasks, leaning on a software development lifecycle is still the most effective and efficient way to build it.

In the meantime, the US blew up with COVID, throwing the financial markets (which my new FinTech project was heavily dependent on) into turmoil. So like any good (read: desperate) startup founder, I scrapped the FinTech project and started building the tool that I wish had existed to help me build integrations to my prospective customers' other SaaS apps. And despite never having touched the language, I decided to build it in Elixir.

### Choosing Elixir

I've spent most of my career as a software engineer writing in Javascript and Ruby. I've long been intrigued by the concepts behind functional programming (years ago I wrote a small toy to try to achieve immutability on the web, like a centralized IPFS), and a friend introduced me to Elixir, which incorporated some Ruby syntax, making it a bit friendlier to get started with.

The concepts behind Erlang/OTP/Elixir make it a great fit for a tool like the one I was building. I knew it would be heavily dependent on outside services, meaning it had to be robust to crashes and other unforeseen events. And I knew high concurrency and low latency would be important features as a piece of developer infrastructure. I also wanted to test out [Paul Graham's theory of hiring programmers](http://www.paulgraham.com/pypar.html): choose a good language and great programmers will always want to work for you. And finally, I'd be lying if I said there wasn't a part of me that just wanted to try something new. I had spent the past two years working an idea I had to shut down, my "big pivot" was a non-starter, I had laid off nearly the entire team, and for product development it was just me in my bedroom. So I liked the idea of learning something new while working on my second pivot in 3 months.

### Learning Elixir

I read through [Elixir's fabulous language guide](https://elixir-lang.org/getting-started/introduction.html). I mean I really read it, cover to cover, and did pretty much all the examples as they came up. Then I read through a handful of pages in the Phoenix (the most popular web framework for Elixir) guides before I said "f*** it" and started building what became Xkit. My first commit was on May 14, 2020. Commit message: "Initial install with platforms".

The first week was rough. I wasn't used to moving this slowly, but not only was a learning a new language with features pretty unfamiliar to me like pattern-matching, I was learning a new paradigm. Javascript is whatever you want it to be, which means I had some exposure to FP incidentally, but almost everything I've spent significant time on has had a pretty object-oriented flavor to it, even dating back to when I first got started with PHP. Not to mention the entire ethos of OTP to "fail fast and noisily" which ran counter to so many experiences which focused on avoiding failure at all costs (yes, I've seen some pretty large `try`/`catch` blocks in my day). I got pretty discouraged at the pace I was moving, and somewhere about 10 days in I was really regretting not just using Node/Express, a stack I was so familiar with it felt like I could write the app in my sleep.

But I kept at it (probably more out of pride than anything else) and a few days later I felt things start to shift. I still wasn't moving fast, but I could tell I was improving. Things that only a few days ago had felt foreign and impossible to grasp started to make sense. From that point on I started accelerating, and on June 1st, I sent one of my investors [this video](https://www.youtube.com/watch?v=7dJi3sAsHM0) showing the first version of what became Xkit.

{% youtube 7dJi3sAsHM0 %}

### Shortcomings of Elixir and Phoenix

I started off trying to use a pure Phoenix stack including their new real-time front-end, [LiveView](https://github.com/phoenixframework/phoenix_live_view). I'll be honest, although I really like Elixir and Phoenix, using Phoenix for the front-end brought me back a bit to my Rails days, and not in a good way. Building a modern web application with those tools felt like I'd be working against the tide. I also am pretty partial to [Evergreen](https://evergreen.segment.com), the React UI kit by Segment, and I was bearing down on the 6 week timeline I'd set for myself to launch this product. So I ripped out the Phoenix front-end and converted it to be a back-end only application and built a new front-end in React and Evergreen. I did end up using Phoenix's websocket implementation which was a big help integrating the two, although some pieces are not very well documented.

When I finally getting close to launching, I ran up against the greatest weakness of my choice to use Elixir: deployment. While the world has moved towards a serverless paradigm, Elixir/Erlang/OTP thrive by handling a lot of the same things that "serverless" promises. That means that to really take advantage of all it has to offer, you're better off deploying it on as close to bare metal as you can. That, in addition to some of the architecture choices I made with Xkit (specifically to provision a custom subdomain for every user), made deployment quite a challenge. Failing to find any good documentation about how to deploy a Phoenix application on AWS, I ended up [writing a blog post about our process](https://xkit.co/post/deploying-phoenix-for-elixir-on-aws-ec2).

You might think it's overkill for a one-person development team to have a one-command deploy process, but I assure you, based on my past experience, it's well worth the effort. You don't want critical DevOps knowledge in one person's head, or worse, on some inscrutable AWS GUI. I want it all in code. Even today, you can take the entire Xkit stack, move it to a new AWS account and have it up and running with a single command in around 30 minutes.

### Launching Xkit

The delays I hit caused me to miss my six week launch goal by two weeks: I launched to some fellow YC founders on July 12 with \~15 connectors and [this video](https://www.youtube.com/watch?v=7MqwQ3Czejs).

{% youtube 7MqwQ3Czejs %}

Two weeks after that I launched on [Product Hunt](https://www.producthunt.com/posts/xkit) and shortly after that on [Hacker News](https://news.ycombinator.com/item?id=24121290) with over 25 connectors. Since then we've worked with some really great early customers who have helped us refine the product, and I've been able to hire a few friends to help grow the business.

We're well over 50 connectors at this point (almost entirely driven by customer requests) and we add so many that we no longer track it as a metric. And while I'm still contributing code, I can safely say that the majority of the coding that I will do for Xkit is now likely behind me. But the process of building Xkit (and learning Elixir in the process) has been incredibly rewarding, and hopefully we're just getting started.



PS - In case you're wondering about the answer to PG's theory about language being a good hiring tool - my early results indicate that it is. From a single post on [Elixir Forum](https://elixirforum.com) I met one of the best engineers I've seen, and a few weeks later he recruited one of the best engineers he'd worked with to join the team.