https://docs.appsignal.com/application/markers/deploy-markers.html

As long as you have an APP_REVISION environment variable set, you will send it to Appsignal through the integration library.

In the case of Railway you can quite easily add the variable to your Dockerfile and have everything work out nicely in 2 lines.

Railway even provides the variable automatically for you.

# At the very end of your Dockerfile:

# This is a variable Railway automatically exposes.
# Add the variable.
ARG RAILWAY_GIT_COMMIT_SHA 

# Use the variable
ENV APP_REVISION=$RAILWAY_GIT_COMMIT_SHA

CMD ["/app/bin/server"]

And that's it. Deploy markers will now work for you.

It occurred to me this week after seeing some devs on twitter arguing about vercel/self-hosted/serveless that I have ever deployed a Phoenix app myself, by hand, the good old fashioned way. I've always used a PaaS, be that Gigalixir, Heroku, Render, Railway, Fly. The last time I manually deployed something was with PHP in 2012.

Maybe the newer generation of devs know no other way, so I want you to take 30 minutes of your day today, give this a shot, and take a peek at how the sausage is made. It's not as scary as you think!

This is not a production ready server. Missing: firewals, security, domains, ssl, rolling deploys, backups, etc.

The Setup: Creating Our Phoenix Project

First things first, let's whip up a new Phoenix project. We're going with LiveView because, well, it's awesome, and we're using binary IDs because we're cool like that. Fire up your terminal and let's get cracking:

mix phx.new pokemon --binary-id --live
cd pokemon

Setting Up Our Digital Ocean Droplet

Alright, now we're going to set up our cozy little home in the cloud. Head over to DigitalOcean and create a new Droplet. Here's what you want:

• Region: New York

• Datacenter: 1

• OS: Ubuntu 24.04 LTS x264

• Plan: Regular SSD, $4/month

Set up root password authentication and make sure to copy that IPv4 address. You're gonna need it!

Connecting to Our Droplet

Time to make friends with our new Droplet. In your terminal, type:

ssh root@your-ip

Accept that SSH key fingerprint (it's cool, trust me) and enter your root password. Boom! You're in.

Updating Our System

Let's make sure our new cloud home is up to date:

sudo apt update && sudo apt upgrade -y

Installing PostgreSQL 16

Now, we need a place to store all our Pokémon data. Enter PostgreSQL 16:

sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
sudo apt update
sudo apt install postgresql-16 -y

Start it up and make sure it runs on boot:

sudo systemctl start postgresql
sudo systemctl enable postgresql

Configuring PostgreSQL

Time to set up our database. We're going with 'pokemon' as our password because, well, why not?

sudo -u postgres psql -c "ALTER USER postgres PASSWORD 'pokemon';"

Now, let's make PostgreSQL accessible from anywhere (don't worry, we'll secure it later):

sudo nano /etc/postgresql/16/main/postgresql.conf
# Change: listen_addresses = '*'

sudo nano /etc/postgresql/16/main/pg_hba.conf
# Add: host all all 0.0.0.0/0 md5

Restart PostgreSQL and open up the firewall:

sudo systemctl restart postgresql
sudo ufw allow 5432/tcp

Create our app's database:

sudo -u postgres psql
CREATE DATABASE pokemon;
CREATE USER pokemon WITH PASSWORD 'pokemon';
GRANT ALL PRIVILEGES ON DATABASE pokemon TO pokemon;
\q

Installing Dependencies

Our Droplet needs some tools to run our Phoenix app:

sudo apt install -y build-essential inotify-tools
sudo apt install elixir

Setting Up Caddy

We're using Caddy as our web server because it's simple and awesome. Let's install it:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy

Start it up:

sudo systemctl start caddy
sudo systemctl enable caddy

Preparing Our App for Deployment

Back on your local machine, let's get our Phoenix app ready for the big leagues:

mix assets.deploy
MIX_ENV=prod mix compile
MIX_ENV=prod mix phx.digest
MIX_ENV=prod mix release
tar -czf pokemon.tar.gz -C _build/prod/rel/pokemon .

Now, let's send it to our Droplet:

scp pokemon.tar.gz root@your_droplet_ip:/opt/pokemon/

Deploying Our App

On the Droplet, extract our app:

tar -xzf /opt/pokemon/pokemon.tar.gz -C /opt/pokemon

Configure Caddy to serve our app:

sudo nano /etc/caddy/Caddyfile

Add this to the Caddyfile:

:80 {
    root * /opt/pokemon
    file_server
    try_files {path} {path}/ /index.html
    reverse_proxy localhost:4000
}

Restart Caddy:

sudo systemctl restart caddy

Finally, start our Phoenix app:

/opt/pokemon/bin/pokemon start

And there you have it, folks! Your Phoenix app should now be live on your Droplet's IP address. Go ahead, give it a visit in your browser. You should see your app running in all its glory!

So now you guys know how the sausage is made. You've peeked behind the curtain and perhaps gained new appreciation to what PaaS providers abstract away for you. Or maybe you decided this is totally easy and something you can handle yourself. Either way the choice is your now and you're informed.

Where to next?

The next step beyond this simple first implementation would be to use something like Kamal or Coolify. Beyond that use a PaaS like Fly.io

Here's how to easily do it in Rails 7, using Postgres!

Configure your generators to use UUID for keys.

Create a file in config/initializers/generators.rb

Rails.application.config.generators do |g|
  g.orm :active_record, primary_key_type: :uuid
end

Now when you generate models it'll automatically use uuids for the primary keys. This even works automatically for things like action_text.

Here's what the action_text generator will create for you:

# This migration comes from action_text (originally 20180528164100)
class CreateActionTextTables < ActiveRecord::Migration[6.0]
  def change
    # Use Active Record's configured type for primary and foreign keys
    primary_key_type, foreign_key_type = primary_and_foreign_key_types

    create_table :action_text_rich_texts, id: primary_key_type do |t|
      t.string     :name, null: false
      t.text       :body, size: :long
      t.references :record, null: false, polymorphic: true, index: false, type: foreign_key_type

      t.timestamps

      t.index [ :record_type, :record_id, :name ], name: "index_action_text_rich_texts_uniqueness", unique: true
    end
  end

  private
    def primary_and_foreign_key_types
      config = Rails.configuration.generators
      setting = config.options[config.orm][:primary_key_type]
      primary_key_type = setting || :primary_key
      foreign_key_type = setting || :bigint
      [primary_key_type, foreign_key_type]
    end
end

Notice the id type! Pretty nifty.

Make sure your foreign keys use UUID!

When you start creating more tables, make sure the type is correct.

class CreateQuotes < ActiveRecord::Migration[7.1]
  def change
    create_table :quotes, id: :uuid do |t|
      t.text :favorite_quote
      t.uuid :user_id

      t.timestamps
    end
  end
end

t.uuid! Don't forget!

And it's that easy.

I think it's one of the wonders of the world. A feat in engineering that has had so many people working on it, too powerful for one person to know every nook and cranny. It's gargantuan and incredibly complex.

It also fits too many use cases to count!

Here's my cookbook for FFmpeg. Useful recipes I use almost daily to share things online with friends, archive for myself and otherwise fiddle around with things.

Create a timelapse using pictures in a folder.

ffmpeg -framerate 30 -pattern_type glob -i '*.JPG' -c:v libx264 -r 30 -pix_fmt yuv420p timelapse.mp4

Add meme caption to videos.

ffmpeg -i "video.mp4" -vf "drawtext=text='TOP TEXT':fontfile='C\:\\Windows\\Fonts\\arial.ttf':fontcolor=white:fontsize=72:borderw=5:x=(w-text_w)/2:y=(h*0.05)" -c:a copy output_with_top_text.mp4

ffmpeg -i "video.mp4" -vf "drawtext=text='ROFL':fontfile='C\:\\Windows\\Fonts\\arial.ttf':fontcolor=white:fontsize=72:borderw=5:x=(w-text_w)/2:y=(h*0.05), drawtext=text='LMAO':fontfile='C\:\\Windows\\Fonts\\arial.ttf':fontcolor=white:fontsize=72:borderw=5:x=(w-text_w)/2:y=(h-text_h)-(h*0.05)" -c:a copy output_with_text.mp4

Convert video to Twitter friendly format.

ffmpeg -i video.mp4 -vcodec libx264 -pix_fmt yuv420p -strict experimental -r 30 -t 2:20 -vf "pad=ceil(iw/2)*2:ceil(ih/2)*2" -vb 1024k -acodec aac -ar 44100 -ac 2 -minrate 1024k -maxrate 1024k -bufsize 1024k -movflags +faststart output.mp4

Convert video to WhatsApp friendly format.

ffmpeg.exe -i video.mp4 -c:v libx264 -profile:v baseline -level 3.0 -pix_fmt yuv420p video-whatsapp.mp4

Convert a funny gif to shareable friendly MP4 format.

First, loop the GIF a few times so the video plays and people can enjoy your meme! Then convert that bigger GIF to an MP4.

ffmpeg.exe -stream_loop 3 -i .\funny.gif funny-loop.gif
ffmpeg.exe -i funny-loop.gif -f gif funny-loop-whatsapp.mp4
ffmpeg.exe -i funny-loop-whatsapp.mp4 -c:v libx264 -profile:v baseline -level 3.0 -pix_fmt yuv420p output.mp4

Convert video to x265 for archiving (same resolution).

ffmpeg.exe -i myvideo.mp4 -c:v libx265 -vtag hvc1 -c:a copy myvideo-x265.mp4

Trim video and grab specific timestamps.

ffmpeg.exe -ss 00:00:10 -t 10 -i '.\Lord of war [K1HEibypsTY].webm' trim.mp4

Mix audio on to video.

Here my audio is larger than my video, and I want to mix the audio in with the video and cut it off. -shortest will use whichever is shorted, audio or video.

ffmpeg.exe -i .\trim.mp4 -i audio.mp3 -c copy -map 0:v:0 -map 1:a:0 -shortest mix.mp4

Add the deb url to your sources list

sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt/ focal-pgdg main" > \      
/etc/apt/sources.list.d/postgresql.list'

Add postgres' official key

wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -

Update and upgrade apt

sudo apt update
sudo apt upgrade

Install postgresql-13

sudo apt-get install postgresql-13 postgresql-client-13

Run the postgres 13 service

sudo systemctl status postgresql

Verify you have everything installed

psql --version                                                              
psql (PostgreSQL) 13.5 (Ubuntu 13.5-1.pgdg20.04+1)

You're done!

Here's how to easily get rid of them in Brave Browser.

Type in brave://adblock/ in the address bar and hit .

Scroll all the way down to find the custom ruleset input. Here's you can add the rule to block these annoying youtube end screen blocks.

youtube.com##.ytp-ce-element

There is no save button so click out of the input somewhere and wait a bit then refresh to confirm the rule was saved.

No more annoying youtube end screen boxes!

Note: This guide assumes you're on Liveview 0.17.5 or newer because we depend on the new liveview event hooks.

First install the appsignal_phoenix package. Because this package already depends on the appsignal package, there's no need for you to manually add it.

defp deps do
  [
    {:appsignal_phoenix, "~> 2.0"},

Then we're going to hook into the lifecycle in two spots. One for the mount event, and one for the handle_event.

In your myproject_web.ex add two on_mount handlers.

  def live_view do
    quote do
      use Phoenix.LiveView,
        layout: {GamingWeb.LayoutView, "live.html"}

      on_mount(GamingWeb.InitAssigns)
      on_mount(GamingWeb.Appsignal)

      unquote(view_helpers())
    end
  end

Tracking mount events

Let's start by creating the InitAssigns module.

defmodule GamingWeb.InitAssigns do
  @moduledoc false
  import Phoenix.LiveView
  import Appsignal.Phoenix.LiveView, only: [live_view_action: 5]

  def on_mount(:default, params, session, socket) do
    # here's where we're calling appsignal instrumentation
    live_view_action(socket.view, "mount", params, socket, fn ->
      socket =
        socket
        |> assign_new(:current_user, fn ->
          get_user(session["user_token"])
        end)

      {:cont, socket}
    end)
  end
end

We're done, every mount will be tracked properly on Appsignal.

Tracking handle_event events

We're going to track the handle_event lifecycle event. If you want you can track others like:

defmodule GamingWeb.Appsignal do
  @moduledoc false
  import Phoenix.LiveView
  import Appsignal.Phoenix.LiveView, only: [live_view_action: 5]

  def on_mount(:default, _params, _session, socket) do
    socket =
      attach_hook(socket, :mount_hook, :handle_event, fn
        event, params, socket ->
          live_view_action(socket.view, event, params, socket, fn ->
            {:cont, socket}
          end)
      end)

    {:cont, socket}
  end
end

And we're done. Here I'm tracking a simple form event named submit.

def handle_event("submit", %{"waitlist" => params}, socket) do
  {:noreply, socket}
end

Do you know why FAANGM companies have these very complicated interview processes? Because they get literally thousands of applicants for a position.

They need some kind of way to cull 99% of applications. What's the easiest way to do that? Leetcode/hackerrank type questions. These companies unceremoniously reject thousands of engineers and whoever is left at the end gets to experience the real interview process. The one where people actually listen to you and ask about your experience.

Your company is not FAANGM. You do not get thousands of applicants. You are not scaling to two-hundred million users across the globe.

You are missing out on great candidates.

How do I fix it? How do I find talented people?

It's really simple and the results are great. Here's my current interview process:

1. First round 30 minute interview with me, the VP of Engineering.
   • We talk about your previous experience.
   • Career goals, what you want to work on.
   • I see if it's a good fit for the problems I need solved.
2. Take-home assignment that takes about 5 hours to complete.
   • This is a real project with a proper README.md to get it running locally.
   • Since we work with real-time data and data ingestion, our take-home reflects what you will be doing all day. No leetcode. Just good old fashioned: "can you do what we need you to do?"
   • Talk to an API, render results in real-time, allow users to favorite a line-item. Focused.
3. Screenshare for one hour to review your take-home.
   • You, one of our engineers and I sit down and go through the three tasks we asked you to complete, and you talk about your solution.
   • Very casual, low stress.
   • We poke holes, discuss alternative approaches and get a feel for what it would be like to work with you.

There is no step 4.

This only works if you have engineers on your team

If your founding team is non-technical, you cannot take this approach. In these cases, I recommend using a service like Karat I have taken a Karat interview once and the tool was serviceable, and process was technically sound.

But if you do have engineers on your team, give out take-home assignments. Give people a chance to show you what they are capable of and you will find the talent you need.

Being able to find rectangles in a grid of 0's and 1's doesn't mean that person will be able to deliver a good product and find product-market fit.

Would you like to experience our interview process? I'm hiring!

https://docs.google.com/document/d/1Gu3l1J8zh56MOCp-jpzLGbifOIHb2iGbX31qikLI384/edit?usp=sharing

Apply now and help us find awesome product-market fit in the esports gaming industry.

Here's how to automatically use different ssh keys for different projects on the same machine.

Create two different ssh keys

Make sure you add your public keys to each of your github accounts. Pretty straightforward.

Create a config file in ~/.ssh

Include this:

# My github username is sergiotapia
Host github.com-sergiotapia
    HostName github.com
    User git
    IdentityFile ~/.ssh/mypersonalidentity
        IdentitiesOnly yes        

# Assume my organization is called mycompany
Host github.com-mycompany
    HostName github.com
    User git
    IdentityFile ~/.ssh/myworkidentity
        IdentitiesOnly yes

Configuring your git remotes to properly use the right key

There's two ways for you to go about this.

For new projects you need to clone:

Clone the project using github.com-mycompany or github.com-sergiotapia.

git clone git@github.com-mycompany:mycompany/backend-api.git

# or your personal account

git clone git@github.com-sergiotapia:sergiotapia/backend-api.git

For existing projects you have locally but need to work on.

Set the git remote using the proper naming structure.

git remote remove origin
git remote add origin git@github.com-mycompany:mycompany/backend-api.git

# or your personal account

git remote remove origin
git remote add origin git@github.com-sergiotapia:sergiotapia/backend-api.git

There's very little material out there describing how to set up a liveview, tailwind jit and alpine project using Phoenix 1.6.0

Here's a little guide I pieced together out of forum posts, tweets, github issues and IRC. I can't thank everyone who helped me enough, they did the work, I just compiled it here for posterity.

If you're impatient just look at the code commits, it's this article step by step.

https://github.com/sergiotapia/golden

Update #1, November 11, 2021:

Alpine ^3.5.0 now targets es2017 so make sure you update config/config.exs. Check the last commit in the repo for a quick fix.

At the time of writing, Phoenix 1.6.0-rc.0 is out! https://www.phoenixframework.org/blog/phoenix-1.6-released

Create your project.

mix phx.new golden --live

In the assets folder, install dev dependencies, also install alpinejs as a prod dependency.

cd assets/
npm install autoprefixer postcss postcss-import postcss-cli tailwindcss --save-dev
npm install alpinejs

Configuring the Javascript pipeline.

We use esbuild to build our javascript payload.

Make sure you comment out line 3 of app.js, if you don't esbuild will also compile your css and will thrash any CSS pipelines you set up for tailwind jit. We will use postcss for CSS building later in this article.

// We import the CSS which is extracted to its own file by esbuild.
// Remove this line if you add a your own CSS build pipeline (e.g postcss).
// import "../css/app.css"

Add alpinejs to your app.js file and make sure you configure the livesocket to call alpine on dom updates.

// import Alpine
import Alpine from "alpinejs";

// Add this before your liveSocket call.
window.Alpine = Alpine;
Alpine.start();

---
// Add dom update support for Alpine.
// before:
let liveSocket = new LiveSocket("/live", Socket, {params: {_csrf_token: csrfToken}})

// after:
let hooks = {};
let liveSocket = new LiveSocket("/live", Socket, {
  params: { _csrf_token: csrfToken },
  hooks: hooks,
  dom: {
    onBeforeElUpdated(from, to) {
      if (from._x_dataStack) {
        window.Alpine.clone(from, to);
      }
    },
  },
});

Configuring the CSS pipeline

This one is pretty complicated but bear with me.

Create postcss.config.js file in assets folder.

module.exports = {
  plugins: {
    'postcss-import': {},
    tailwindcss: {},
    autoprefixer: {},
  }
}

Create tailwind.config.js file in assets folder.

module.exports = {
  mode: "jit",
  purge: ["./js/**/*.js", "../lib/*_web/**/*.*ex"],
  theme: {
    extend: {},
  },
  variants: {
    extend: {},
  },
  plugins: [],
};

Add Tailwind's basic css imports to the top of your app.css file.

@import "tailwindcss/base";
@import "tailwindcss/components";
@import "tailwindcss/utilities";

Finally, add a watcher to dev.exs so your compiled app.css is automatically reloaded as you work on your project.

# dev.exs should ultimately end up looking like this:
config :golden, GoldenWeb.Endpoint,
  # Binding to loopback ipv4 address prevents access from other machines.
  # Change to `ip: {0, 0, 0, 0}` to allow access from other machines.
  http: [ip: {127, 0, 0, 1}, port: 4000],
  debug_errors: true,
  code_reloader: true,
  check_origin: false,
  watchers: [
    # Start the esbuild watcher by calling Esbuild.install_and_run(:default, args)
    esbuild: {Esbuild, :install_and_run, [:default, ~w(--sourcemap=inline --watch)]},
    npx: [
      "tailwindcss",
      "--input=css/app.css",
      "--output=../priv/static/assets/app.css",
      "--postcss",
      "--watch",
      cd: Path.expand("../assets", __DIR__)
    ]
  ]

At this point you should have nice working development environment.

Just run mix phx.server and visit https://localhost:4000

Let's figure out deployment to production next.

Create a deploy script in package.json

"scripts": {
    "deploy": "NODE_ENV=production postcss css/app.css -o ../priv/static/assets/app.css"
  },

Modify the assets.deploy alias in mix.exs

defp aliases do
    [
      setup: ["deps.get", "ecto.setup", "cmd --cd assets npm install"],
      "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
      "ecto.reset": ["ecto.drop", "ecto.setup"],
      test: ["ecto.create --quiet", "ecto.migrate --quiet", "test"],
      "assets.deploy": [
        "cmd --cd assets npm run deploy",
        "esbuild default --minify",
        "phx.digest"
      ]
    ]
  end

Finally let's build a build.sh at root folder deploy script. This will build our app using Elixir releases in prod MIX_ENV and digest our static js and css assets.

#!/usr/bin/env bash
# exit on error
set -o errexit

# Install deps
npm install --prefix ./assets
mix deps.get --only prod

# Initial setup
MIX_ENV=prod mix assets.deploy
MIX_ENV=prod mix compile

# Migrate the database
MIX_ENV=prod mix ecto.migrate

# Build the release and overwrite the existing release directory
MIX_ENV=prod mix release --overwrite

Give that script run permissions.

chmod a+x build.sh

Run the build script.

./build.sh

Note: This command WILL FAIL because you need to set up a database url environment variable for prod MIX_ENV. Set that up using your database of choosing.

I joined two years ago as the first engineering hire. My role was Director of Engineering. The technical team at the time was an offshore engineering firm with a specialty for Elixir work. The co-founders, Andrew and Alfredo, wanted someone local to Miami, experienced in leading engineering teams, and experienced with our tech stack.

I'm writing this article because there is such a draught of content for engineering leadership in that "growth" phase. All I've seen is "CTO" articles from people leading a 2 person team, or articles from an experienced CTO that is leading a public 600 person engineering team. No real in-betweens.

Here are some of the lessons I learned leading Papa's engineering organization from Series A all the way to Series C. What I learned when our engineering team grew to 2 people, 4 people, 10 people, 25 people, 55 people.

This is the start of what I like to call "Growth CTO" lessons.

2-10 Engineers

velocity and one goal

Our tech stack has always been very modern and included things like Elixir, Graphql, and React Native.

The first thing I did when I joined was soaking in the technical choices that were made by the outsourcing firm. A lot of the choices made were great, and some had to be changed more to my liking.

As I hired our first 10 engineers, my responsibilities transitioned more to people management. I still spent most of my time coding, but right around hire #5, I noticed more time spent on planning and building the engineering culture. A lot of time spent talking about our products, how our business functions, how we make money, who are our customers -- I wanted my engineers to understand this well so they knew who they were building these products for and why it was important.

This is when you want to set your org foundations.

As an engineering org, what do you value most? Some teams care about quality, others care about velocity, others care about adhering to a process.

Whatever you choose, make sure to make it explicit and repeat it over and over to your team. Something new managers do not realize until it's too late is that what you say seldom sticks the first few times you say it. Whatever you value most from your team, put it in the engineering handbook and bring it up often during all-hands. Make people realize you care about this first and foremost and you are judging performance based on it.

I set up 1-on-1s, sprint planning sessions, and daily standups with the engineering team. I had the engineers reporting directly to me but we didn't really have skip-level reporting structures set up.

11-30 Engineers

no more coding, much more teamwork

We started growing very rapidly, making deals with really great customers and I found myself working with thirty engineers. Suddenly coordinating work between team members was much more difficult.

We used the "Spotify" method to organize our product teams. Each team had a proper mixture of backend/mobile/web/design and they focused on one product. We called them a "Papa Pod".

At this stage, I was promoted to VP of Engineering and I promoted my most senior backend engineer to Director of Engineering. As I hired more people into our teams, our engineers with longer tenure began asking about promotions and career opportunities at our organization. Understandably, they were concerned that I was hiring a lot of very experienced engineers.

My tip to you reader is to get a career ladder on paper as soon as you close your Series B. Work with your HR department, look online (I'm going to write an article about this in the future), or ask around your personal network. You may notice one person's stress, but a team hides stress very well.

I set up clearer reporting lines. We had people who enjoyed doing player-coach type work with at most 6 direct reports. I had my 1-on-1s with the coaches and executive team. I did very little coding at this stage. I focused entirely on our culture, optimizing our delivery process, unblocking teams when they needed assistance, recruiting, and onboarding.

The decisions you made earlier in the company's life start to take automatic shape here and both good and bad are amplified.

31-55 Engineers

Building a strong team culture

When we hit the 50th Engineer milestone, almost all of my time was spent focused on management and training other engineering managers. I hired a Director of Engineering QA as well. Every decision I made at the start of this journey really started playing out before my eyes. All the training you gave your managers really pays off at this size. Keep your ears open, it's very easy to not know if bad things are happening within your org at this size. Have bi-weekly engineering all-hands to talk with your entire team about the company, the team, the work being done.

Platform team! I found people within the org that had a knack and desire for this kind of work and they began working on the infrastructure behind our software. Early discussions about service-oriented architecture, as our monolith setup was becoming very complex to maintain and ship.

The love I have for this job now comes from getting other people big wins. I spend time unblocking our product teams, empowering my engineering teams, and comforting people who have worked so hard for us and making sure their needs are thoughtfully considered.

60-150 Engineers

What's next? We have grown tremendously fast, our clients love us and we love them. I've seen this company grow from 24 people to 450 people and somehow still maintain such a warm inviting culture. As the engineering org grows it will require a lot of deliberate effort to maintain our culture and scale our reporting lines.

This will be my primary responsibility.

In my next article, I'll talk about how to identify player coaches for potential future management roles in your engineering organization.

[
    {
        "name":"Sergio",
        "favoriteMovie":{
            "title":"Taxi Driver",
            "releaseYear":1976
        }
    },
    {
        "name":"Daniel",
        "favoriteMovie":{
            "title":"Frozen",
            "releaseYear":2013
        }
    }
]

It’s pretty easy, first let’s start by creating the types to marshal the json into.

type
  Movie* = object
    title*: Option[string]
    releaseYear*: Option[int]

type 
  Person* = object
    name*: Option[string]
    favoriteMovie*: Option[Movie]

Then it’s just a matter of parsing the json and using the to function to marshal into a seq[Person].

import json
import strformat
import options

type
  Movie* = object
    title*: Option[string]
    releaseYear*: Option[int]

type 
  Person* = object
    name*: Option[string]
    favoriteMovie*: Option[Movie]

let responseJson = """
[
    {
        "name":"Sergio",
        "favoriteMovie":{
            "title":"Taxi Driver",
            "releaseYear":1976
        }
    },
    {
        "name":"Daniel",
        "favoriteMovie":{
            "title":"Frozen",
            "releaseYear":2013
        }
    }
]
"""

let parsedJson = parseJson(responseJson)
let list = parsedJson.to(seq[Person])
echo $list

The output you’ll see is as expected.

@[(name: Some("Sergio"), favoriteMovie: Some((title: Some("Taxi Driver"), releaseYear: Some(1976)))), (name: Some("Daniel"), favoriteMovie: Some((title: Some("Frozen"), releaseYear: Some(2013))))]