Here is a very simple example of dispatch in action. When user clicks the checkbox in Masterlist, it emits an event. The other checkbox under the overlay is listening for that event, and changes it’s status accordingly.

Example

Here are two containers, <main> and <aside>. They both checkboxes with Stimulus controllers attached to them. When you click the checkbox in <aside>, the change should reflect to a checkbox in<main>.

<main>
  <label>
    <input type="checkbox" 
          data-controller="checkable" 
          data-checkable-id-value="1"
          data-action="checkable:statusChanged@window->checkable#setStatus">
    Cats
  </label>
  <label>
    <input type="checkbox" 
          data-controller="checkable" 
          data-checkable-id-value="2"
          data-action="checkable:statusChanged@window->checkable#setStatus">
    Dogs
  </label>
</main>
<aside>
  <label>
    <input type="checkbox" 
           data-controller="checkable" 
           data-checkable-id-value="1" data-action="click->checkable#toggle">
    Cats
  </label>
  <label>
    <input type="checkbox" 
           data-controller="checkable" 
           data-checkable-id-value="2" data-action="click->checkable#toggle">
    Dogs
  </label>
</aside>

The checkboxes in <main> will lister for custom checkable:statusChanged events. The checkboxes in <aside> lister for JavaScript DOM click events. Those events enable the communication between the different checkboxes.

The checkboxes also have [data-checkable-id-value] that is used to define a value for Stimulus controller. It’s used to distinct the checkboxes from each other, the id is shared between a checkbox in <main> and <aside>.

Stimulus Controller

This is the controller that handles the communication between two checkboxes. The id is the identifier between the checkbox in <main> and <aside>. It’s the secret sauce to syncronize the checked-attribute between the two checkboxes.

The checkable:statusChanged@window->checkable#setStatus in HTML is the part where the listening controller action is defined. In order to listen events emitted outside the controller’s scope, you need to add @window after the event name.

// checkable_controller.js

import { Controller } from "@hotwired/stimulus"

export default class extends Controller {
  static values = {
    id: Number // shared identifier of checkboxes in <main> and <aside>
  }

  setStatus(ev) {
    const id = ev.detail.id;
    const checked = ev.detail.checked;
    if(id == this.idValue) {
      // without the id == this.idValue check, this code
      // would run on every checkbox inside <main>
      this.element.checked = checked;
    }
  }

  toggle(ev) {
    // this.idValue is the shared identifier of
    // checkboxes in <main> and <aside>
    const detail = {
      id: this.idValue,
      checked: ev.target.checked
    }
    // better to use descriptive events, so
    // let's go with 'statusChanged'
    this.dispatch('statusChanged', { detail: detail })
  }
}

That’s about it. The example above is also in Codepen.

Stimulus controllers are so simple that the blog post is short as well! 🙂

To make things way easier, I’m assuming your Ruby on Rails application uses SQLite3 for database.

It’s fair to mention that there are easier options for deploying Ruby on Rails applications:

• Kamal is the “offical” tool for deploying Ruby on Rails 8 applications (requires Docker)
• Capistrano is a battle-tested deployment tool and it’s been around since the early days of Ruby on Rails

I’ve tried both options, but I wanted even simpler way to deploy my applications. That’s where this blog post came from.

Before continuing, here are few things you need to understand

• This article assumes you are using Ubuntu Linux, these instructions might not work if you’re using any other Linux distribution
• In this article, example.com will be used as a placeholder for your own domain or IP-address, adjust accordingly
• You have to configure the firewall (I’m using UFW)
• You have to secure the SSH server (disable root login, disable password login)
• You know how to set up SSH public-key authentication for your server
• Configure DNS-records so that your domain’s A-record resolves into server’s IP-address
• Please consider this article as “some guy wrote in Internet”-level information, use your own judgement and common sense
• You can host multiple Ruby on Rails applications in same server by using this method, but you have to understand that apps are deployed using same unix user deploy and therefore are able to write each other directories
• Finally the disclaimer: If you follow the instructions of this article, you will do it at your own risk – I will take no responsibility at all

Now that I’m safe for any legal proceedings, let’s start 😅

The deployment consists of following building blocks

Here is a high level overview how the server will be set up.

• Firewall - Allows at least HTTPS and HTTP requests, remember configuring firewall is out of scope of this article
• Nginx - Webserver which handles the requests from the browser, and routes the requests into Puma application server or directly serves static assets from assets directory
• Puma - Application server which runs your Ruby on Rails application
• SQLite3 - Database server which is embedded into your Ruby on Rails application
• Static assets - Your Ruby on Rails application has public/ directory, Nginx will serve these assets directly without using Puma and saving some precious server resources
• Let’s Encrypt - Generate SSL certificates so you can use HTTPS

The Let’s Encrypt is missing on the diagram, but it has a background process running that keeps the SSL certificates up-to-date.

Creating the deploy user

In this step, you have to connect to your server as root user and create the deploy user.

With --disabled-password option, deploy-user cannot authenticate using password. The only way to do authentication will be public-key authentication

$ adduser --disabled-password deploy
$ usermod -aG sudo deploy

Create a directory for your SSH files and your public key file.

$ mkdir -p /home/deploy/.ssh
$ chown -R deploy:deploy /home/deploy/.ssh
$ chmod 700 /home/deploy/.ssh

Append the contents of your SSH public key into /home/deploy/.ssh/authorized_keys, most likely the file will be empty or you have to create it.

Change the ownership to deploy and limit the file privileges so that SSH process can only read the file. SSH’s public key authentication will not work unless the file privileges are

$ chown deploy:deploy /home/deploy/.ssh/authorized_keys
$ chmod 700 /home/deploy/.ssh/authorized_keys

If you want to make sure, you can check the file privileges with ls -la.

$ ls -la /home/deploy/.ssh/authorized_keys
-rwx------ 1 deploy deploy 748 Nov 27 07:48 /home/deploy/.ssh/authorized_keys

Give deploy-user root-privileges by editing the sudoers-file. Since deploy-user does not have a password, it needs to be disabled on sudoers file as well, otherwise it will ask password when running commands via sudo.

$ visudo

Add this line at the end of file:

deploy ALL=(ALL) NOPASSWD:ALL

That is the only part where you need root-user, from now on you will be using deploy-user when logging in to your production server via SSH.

If you want to know more, head to SSH’s website for details about public-key authentication.

Setting up the server

First, let’s try the public key authentication. Use SSH to connect your server as deploy-user:

$ ssh deploy@example.com

If you see Ubuntu Linux welcome message, you are good to go! The IP-addresses are different for each server.

$ ssh deploy@masterlist.fi
Welcome to Ubuntu 24.04 LTS (GNU/Linux 6.8.0-31-generic x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/pro

 System information as of Wed Nov 27 07:57:18 AM UTC 2024

  System load:           0.0
  Usage of /:            28.3% of 9.76GB
  Memory usage:          33%
  Swap usage:            0%
  Processes:             99
  Users logged in:       1
  IPv4 address for eth0: 192.168.2.1
  IPv6 address for eth2: 0000:0000:0000:0000:0000:ffff:c0a8:0201
...
<<-- clip -->>
...

Last login: Thu Nov 21 15:25:13 2024 from 12.34.56.78
$

Let’s install few packages that you are going to need. We’re going to use sudo command which runs the commands as root-user.

$ sudo apt update
$ sudo apt install -y curl git-core nginx nodejs npm yarn ruby-full build-essential sqlite3 libsqlite3-dev libffi-dev libyaml-dev zlib1g-dev pkg-config

This will install Git, Nginx, NodeJS, Yarn, Npm, development libraries and SQLite3.

Install Yarn since Ruby on Rails uses it.

$ sudo npm install --global yarn

Hosting website via Nginx

To find out if Nginx is already running on your server, use combination of commands ps and grep like this ps aux | grep nginx. If it is running, the output looks like this:

$ ps aux | grep nginx
root       59329  0.0  0.0  65920  2436 ?        Ss   Nov17   0:00 nginx: master process /usr/sbin/nginx -g daemon on; master_process on;
www-data   59330  0.0  0.2  67016 11432 ?        S    Nov17   0:15 nginx: worker process
www-data   59331  0.0  0.2  66908 11056 ?        S    Nov17   0:00 nginx: worker process

When you open your domain with a browser, you will see the default Nginx welcome-screen.

Adding a web site to Nginx

In Ubuntu Linux, Nginx web server lives in /etc/nginx/-directory. The main configuration file is /etc/nginx/nginx.conf.

To keep the main configuration file clean and simple, there are /etc/nginx/sites-available and /etc/nginx/sites-enabled directories to store the site-specific configuration files. They are also known as virtual hosts, you can have multiple virtual hosts running on one server. For example, you can have example.com and anotherexample.com sites running in one Nginx server. It also means you can run multiple Ruby on Rails applications in one server, as long as the server has enough memory and CPU capacity.

Nginx configuration

This is the Nginx configuration file for Ruby on Rails application. It is located in /etc/nginx/sites-available and then it’s symlinked to /etc/nginx/sites-enabled.

Create the file and then create the symlink with this:

$ sudo ln -s /etc/nginx/sites-available/masterlist /etc/nginx/sites-enabled/

Then remove the default virtual host configuration file from sites-enabled/:

$ sudo rm /etc/nginx/sites-enabled/default

The virtual host configuration file has following directives:

• Defines the domains to listen for (in this case, it’s masterlist.fi)
• Configures the socket file to communicate with Puma
• Directive to server static assets directly from Nginx (no need for Puma to handle those)

Example Nginx virtual host file:

# /etc/nginx/sites-available/masterlist

upstream rails_app {
    server unix:///var/www/apps/masterlist/tmp/sockets/puma.sock fail_timeout=0;
}

server {
    server_name masterlist.fi;
    root /var/www/apps/masterlist/current/public;

    location ^~ /assets/ {
        gzip_static on;
        expires max;
        add_header Cache-Control public;
    }

    location = /favicon.ico { access_log off; log_not_found off; }
    location = /robots.txt  { access_log off; log_not_found off; }

    location / {
        proxy_pass http://rails_app;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_redirect off;

        # WebSocket support (if needed)
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

To test if the configuration files are valid, run the following:

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

If everything is working, you need to restart Nginx:

$ sudo systemctl restart nginx

To see the status of Nginx:

$ sudo systemctl status nginx

Securing the connection with Let’s Encrypt

In order to secure the HTTP connection, you need to have SSL sertificate. Let’s Encrypt is a non-profit organization that provides free SSL-sertificates and they have a tools to automatically provision the sertificates. Before Let’s Encrypt, SSL sertificate management was hard and painful, and you had to buy the sertificate from commercial certificate authority.

With Let’s Encrypt, you just run few unix commands and you have a working SSL-sertificate securing your web applications. ❤️

Install a tool called certbot for certificate management. Follow the installation instructions on Certbot homepage.

You should see something similar in your terminal while creating the certificates:

Successfully deployed certificate for masterlist.fi to /etc/nginx/sites-enabled/masterlist
Successfully deployed certificate for www.masterlist.fi to /etc/nginx/sites-enabled/masterlist

Those lines mean that the certbot will make modifications in your virtual host configuration file.

Once you installed a SSL certificate, make sure to restart Nginx and open your URL with your browser. If you see a lock-symbol (🔒) on start of the address bar, you have HTTPS-connection.

You can test if the web server is responding by browsing to https://example.com, remember to use your own domain.

Running you Ruby on Rails application with Puma

Installing Ruby for your deploy user

Your need Ruby to run your Ruby on Rails application, and you need to run Ruby as deploy-user. In order to have total control for your Ruby installation, you need to install it via Ruby package managers.

So first, let’s install rbenv, a Ruby version manager.

Follow the installation instructions on rbenv homepage and come back to this article once you have Ruby running. Remember to install Ruby into your deploy user.

You can check if Ruby was installed correctly by running which ruby, the output should be:

bob@example:~$ which ruby
/home/deploy/.rbenv/shims/ruby

Remember to install bundler with:

$ gem install bundler

Configuring Puma

Puma needs some instructions so it can run your web application, so you need to create a file called config/puma.rb in your Ruby on Rails project in your local development environment.

In the example file below, the Puma is configured to communicate to Nginx using sockets. Log files will be written into tmp/-directory in your application root directory.

Word of warning, I have given zero thoughts on thread configuration, soso regarding thread counts for your appication, you have to do your own research. This file has some good defaults, so it’s a good starting point.

# config/puma.rb

if ENV.fetch("RAILS_ENV", nil) == "production"
  environment ENV.fetch("RAILS_ENV") { "production" }
  directory '/var/www/apps/masterlist/current'

  # Set up socket and pid files
  bind "unix:///var/www/apps/masterlist/tmp/sockets/puma.sock"
  pidfile "/var/www/apps/masterlist/tmp/pids/puma.pid"
  state_path "/var/www/apps/masterlist/tmp/pids/puma.state"

  # Logging
  stdout_redirect "/var/www/apps/masterlist/logs/puma.stdout.log",
                  "/var/www/apps/masterlist/logs/puma.stderr.log",
                  true

  # Preload app for better performance
  preload_app!

  # Handle worker boot
  on_worker_boot do
    ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
  end

  # Specify the PID file. Defaults to tmp/pids/server.pid in development.
  # In other environments, only set the PID file if requested.
  pidfile ENV["PIDFILE"] if ENV["PIDFILE"]

  # Allow puma to be restarted by `bin/rails restart` command.
  plugin :tmp_restart

  # Run the Solid Queue supervisor inside of Puma for single-server deployments
  plugin :solid_queue if ENV["SOLID_QUEUE_IN_PUMA"]

  # Workers (processes)
  workers ENV.fetch("WEB_CONCURRENCY") { 2 }
end

# Threading configuration
threads_count = ENV.fetch("RAILS_MAX_THREADS", 3)
threads threads_count, threads_count

# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
port ENV.fetch("PORT", 3000)

Directory structure on your production server

Our application will live in /var/www/apps/. The /var directory contains things that will be changed over the time, such as log-files, web-sites, databases. It’s a good place for web applications as well.

The directory structure for Ruby on Rails application deployment looks like this:

.
└── apps
    └── masterlist
        ├── current -> /var/www/apps/masterlist/releases/2024-11-22-13-30
        ├── logs
        ├── releases
        │   ├── 2024-11-21-07-45
        │   ├── 2024-11-21-09-11
        │   └── 2024-11-22-13-30
        ├── shared
        │   └── storage
        └── tmp
            ├── pids
            └── sockets

• current - This is a symbolic link to your latest deployment version of your application, in this case current points to releases/2024-11-22-13-30 directory.
• logs - Puma will write two log files, accesses and errors, and both files are in this directory
• releases - This directory contains all deployed versions of your application, everytime you want to deploy a new version of you application, just create a directory and copy all files from your local development environment to here
• shared - All files that will not change between deployments are stored here, the database of your application is placed here so it won’t be erased in every deployment
• tmp - Temporary files, there are files related to the Puma processes, and cache files

The releases/-directory is the core of the deployment process. Each deployment gets own directory and the current/-directory contains the files of newest deployment because it is always symlinked to the latest directory in releases/.

First deployment

Let’s do everything manually for the first deployment. Once everything is working, then sprinkle some automation via bash script.

Create all the required directories mentioned earlier. In this example, the application is called masterlist, change it to match your own application. Also make sure that the directories are owned by the deploy-user account.

$ cd /var/www
$ sudo mkdir apps
$ cd apps
$ sudo mkdir -p masterlist
$ sudo mkdir -p masterlist/logs
$ sudo mkdir -p masterlist/tmp/pids
$ sudo mkdir -p masterlist/tmp/sockets
$ sudo mkdir -p masterlist/shared/storage
$ sudo mkdir -p masterlist/releases
$ sudo chown -R deploy:deploy masterlist # make sure the `deploy`-user owns the directories

Timestamping the deployment (a.k.a. release) and copying files for local development environment

There is a unix command called date which we can use to generate the timestamp of current time.

$ date +"%Y-%m-%d-%H-%M-%S"
2024-11-22-14-44-59

The format is year-month-day-hours-minutes-seconds and it gives your pretty good guarantee that each deployment will have an unique directory.

With the new timestamp, let’s create a directory inside the releases/-directory.

$ cd /var/www/apps/masterlist
$ mkdir releases/2024-11-22-14-44-59

Copy the files from local development environment to production server. Use scp which is a part of SSH toolkit. In your local development environment, switch to the directory of the application and run following command.

# this following command MUST be run on your local development environment (a.k.a. your own computer)
# remember to change the timestamp, the user and the server
$ rsync -av \
  --exclude-from='.gitignore' \
  --exclude '.git' \
  --exclude 'log/*' \
  --exclude 'tmp/*' \
  --exclude 'storage/*' \
  --exclude 'node_modules' \
  --exclude 'public/assets' \
  --exclude 'public/packs' \
  --exclude 'config/credentials/*.key' \
  --exclude 'config/master.key' \
  --exclude '.env*' \
  --exclude 'spec' \
  --exclude 'test' \
  --exclude '.rspec' \
  --exclude 'coverage' \
  --exclude '.DS_Store' \
  --exclude '*.sqlite3' \
  --progress \
  --delete \
  ./ deploy@masterlist.fi:/var/www/apps/masterlist/releases/2024-11-27-11-14-44

Back on the production server, we can create the symbolic link (a.k.a. symlink).

# make sure you are in /var/www/apps/masterlist directory
$ ln -sf releases/2024-11-27-11-14-44/ current

Install gems for your application

$ cd current
$ bundle install

Copy master.key from you local development environment into the shared/-directory on your production server.

# this will be run on your local development environment
$ scp config/master.key deploy@masterlist.fi:/var/www/apps/masterlist/shared/master.key

Everything is ready for Puma to run your Ruby on Rails application from current/-directory and store the database in shared/storage.

You can test that everything works by running rails console in current/-directory. In production server, your application will run in production-mode, therefore we have to use RAILS_ENV=production everytime we run any rails commands.

$ cd current
$ RAILS_ENV=production bin/rails console

But before that, we need to setup the ruby on rails application.

Setting up the application

Create the database by running the database migrations. Make sure you are running the migrations in production mode by prefixing the command with RAILS_ENV=production.

$ cd /var/www/apps/masterlist/current
$ RAILS_ENV=production bin/rails db:create
$ RAILS_ENV=production bin/rails db:migrate

Then you have to compile all assets so they become static assets, to be served by Nginx.

$ RAILS_ENV=production bin/rails assets:precompile

Again, make sure you’re in production environment by writing RAILS_ENV=production before bin/rails assets:precompile.

Test run with Puma

Finally it’s time to start the Ruby on Rails application and that’s the job for Puma. To test that everything works, first let’s start our application manually.

$ cd /var/www/apps/masterlist/current
$ RAILS_ENV=production bundle exec puma -C config/puma.rb

The output should look something like this:

[191034] Puma starting in cluster mode...
[191034] * Puma version: 6.4.3 (ruby 3.3.3-p89) ("The Eagle of Durango")
[191034] *  Min threads: 5
[191034] *  Max threads: 5
[191034] *  Environment: production
[191034] *   Master PID: 191034
[191034] *      Workers: 2
[191034] *     Restarts: (✔) hot (✖) phased
[191034] * Preloading application
[191034] * Listening on unix:///var/www/apps/masterlist/tmp/sockets/puma.sock
[191034] Use Ctrl-C to stop

The line Listening on unix:///var/www/apps/masterlist/tmp/sockets/puma.sock means that now Nginx and Puma have a way for communicating with each other.

Puma is now running, but you have to manually monitor the Puma process and restart it if it crashes.

Unix process management with Systemd

Ubuntu Linux uses systemd for process management. It starts processes, it stops badly behaving processes, it makes sure processes keep running and if they crash, it restarts them.

Systemd is configured in /etc/systemd-directory. There is a directory called /etc/systemd/system that contains configuration files for all processes that need managing. It has a huge role of Linux operating system, things need to be running, spice must flow.

For each Ruby on Rails project that is run on the server, it needs a file in /etc/systemd/system-directory.

Create a file in this directory and name it after your application. In this example the name of the service file is masterlist.service.

[Unit]
Description=Masterlist (Puma Rails Server)
After=network.target

[Service]
Type=simple
User=deploy
WorkingDirectory=/var/www/apps/masterlist/current
Environment=RAILS_ENV=production
ExecStart=/home/deploy/.rbenv/shims/bundle exec puma -C config/puma.rb
Restart=always

[Install]
WantedBy=multi-user.target

Create the service file with using systemctl tool.

$ sudo systemctl edit --force --full masterlist.service

Enable the service and start it too

$ sudo systemctl enable --now masterlist

Query the status of the service:

$ sudo systemctl status masterlist

In case you need to start or stop the service

$ sudo systemctl start masterlist
$ sudo systemctl stop masterlist
$ sudo systemctl restart masterlist # stop the service and start it again

If you need to do some troubleshooting, you can find the logs in /var/www/apps/masterlist/logs.

Sometimes it helps troubleshooting when you open another terminal window and watch the logs in real-time.

$ tail -100f /var/www/apps/masterlist/logs/puma.stdout.log

Press Control-C to exit the logs.

Automating the deployment

The server is set up, Nginx is running, Let’s Encrypt is keeping the connection secure and Puma is hosting Ruby on Rails application. If you do the deployment manually, there are so many steps and so many opportunities to mess things up. I’d suggest you automate that part into a shell script.

To deploy, the newest version of the application is copied to the server into directory that get’s it’s name from timestamp, and it’s then symlinked to current/. After that the assets are compiled into public/-directory for Nginx to directly host them.

I have the following file in my Ruby on Rails application bin/-directory along with Ruby on Rails default commands. I’ve called it bin/deplou since it’s not the perfect deployment system but it works for me.

#!/usr/bin/env sh

# Configure your server and application settings

# IP address or domain addres for your production server
REMOTE_SERVER=188.34.189.36

# User that does the deploy
REMOTE_USER=deploy

# I've found out it's much easier for me to enforce the Ruby version on the server,
# then keep all version numbers in sync
RUBY_VERSION="3.3.3"

# Where you application is located in production server
REMOTE_APP_DIR=/var/www/apps/masterlist

# You shouldn't need to change anything below

TIMESTAMP=`date +"%Y-%m-%d-%H-%M-%S"`


CURRENT_DIR=$REMOTE_APP_DIR/current
DESTINATION_DIR=$REMOTE_APP_DIR/releases/$TIMESTAMP

SECRET_KEY_FILE=config/master.key
STORAGE_DIR=$REMOTE_APP_DIR/shared/storage

DATA_DIR=$REMOTE_APP_DIR/shared/videos
PUBLIC_DIR=$CURRENT_DIR/public


run_ssh() {
    local command=$1
    ssh $REMOTE_USER@$REMOTE_SERVER "bash -l -c 'source ~/.bashrc && eval \"\$(~/.rbenv/bin/rbenv init -)\" && ${command}'"
}

# copy files into new folder (ignore a bunch of directories)
echo "Copying files from local development to production server"
rsync -av \
  --exclude-from='.gitignore' \
  --exclude '.git' \
  --exclude 'log/*' \
  --exclude 'tmp/*' \
  --exclude 'storage/*' \
  --exclude 'node_modules' \
  --exclude 'public/assets' \
  --exclude 'public/packs' \
  --exclude 'config/credentials/*.key' \
  --exclude 'config/master.key' \
  --exclude '.env*' \
  --exclude 'spec' \
  --exclude 'test' \
  --exclude '.rspec' \
  --exclude 'coverage' \
  --exclude '.DS_Store' \
  --exclude '*.sqlite3' \
  --progress \
  --delete \
  ./ $REMOTE_USER@$REMOTE_SERVER:$DESTINATION_DIR

# copy credentials
echo "Copying credentials..."
run_ssh "cp ${REMOTE_APP_DIR}/shared/master.key ${DESTINATION_DIR}/config/master.key"

# Enforce running correct ruby version on $remote
echo "Enforcing Ruby ${RUBY_VERSION} version..."
run_ssh "cd ${DESTINATION_DIR} && echo ${RUBY_VERSION} > .ruby-version"

# Bundle gems
echo "Running 'bundle'"
run_ssh "cd ${DESTINATION_DIR} && which ruby"
run_ssh "cd ${DESTINATION_DIR} && bundle exec bundle"

# build assets
echo "Build assets..."
run_ssh "cd ${DESTINATION_DIR} && RAILS_ENV=production bundle exec rails assets:precompile"

# create symlinks
echo "Creating symlink ${DESTINATION_DIR} => ${CURRENT_DIR}"
run_ssh "ln -nsf ${DESTINATION_DIR} ${CURRENT_DIR}"

echo "Creating symlink ${DESTINATION_DIR}/storage => ${STORAGE_DIR}"
run_ssh "rm -fR ${DESTINATION_DIR}/storage && ln -nsf ${STORAGE_DIR} ${DESTINATION_DIR}/storage"

echo "Restart Puma"
run_ssh "pumactl -P ${REMOTE_APP_DIR}/tmp/pids/puma.pid restart"

And there you go! You’ve reached the end of this long article. Everytime you want to deploy your changes, just run bin/deplou in your Ruby on Rails application root directory.

Final words

Here are some things to consider if you start using this way of deployment

• It bypasses version control completely, so you have to make sure you commit your source code into repository
• The backups are crucial, especially if you have client data, find out way to do regular backups and store the backups somewhere safe (do some research on “3-2-1 backup rule”)
• Make sure you monitor your system, rails_performance gem might be the thing you need
• The log files will eventually fill your hard drive and your server will hang, unless you configure a log rotation scheme for your Puma logs and Nginx Logs – Here is a tutorial how to manage logs with logrotate

There you go, have fun storming the castle! 🙂

First, introduce a new folder called fonts into assets. You also need to create the folder.

# config/application.rb
config.assets.paths << Rails.root.join("app", "assets", "fonts")

Then, setup a folder structure with the font assets your want to use. Put the file that contains all @font-face declarations into app/assets/stylesheets.

I’m using Inter and it has a CSS file with all font-faces. I’ve moved the CSS file into app/asserts/stylesheets/vendor, I like my stylesheets neat and structured.

Here is the folder structure:

# app/assets/

.
├── builds/
├── config/
├── fonts/
│   └── Inter-3.19
│       ├── Inter-Black.woff
│       ├── Inter-Black.woff2
│       ├── ...
│       ├── ...
│       └── Inter.var.woff2
├── images/
└── stylesheets/
    ├── application.sass.scss
    └── vendor
        └── inter-3.19.scss

Make sure the @font-face declarations point into correct folder.

For my needs, I need to add Inter-3.19 into each font-face url since it’s located in subfolder in fonts-folder.

Find and replace all occurences of src: url("Inter-roman.var.woff2?v=3.19") format("woff2"); with src: url("Inter-3.19/Inter-roman.var.woff2?v=3.19") format("woff2");

Finally, import the fonts in your CSS. Add the following into your root CSS file.

@use 'vendor/Inter-3.19';

Setup rotating logs in production

Prevent your log files growing too big and filling up your server storage.

# config/environments/production.rb
config.logger = Logger.new(config.paths["log"].first, "weekly")

Install language server for Ruby and Ruby on Rails

bundle add ruby-lsp-rails

Your editor should pick it up automatically, at least Sublime Text does it.

Email configuration for development environment

I’m using Mailcatcher to do my email styling in development mode.

First, install mailcatcher gem.

gem install mailcatcher

Setup the mail configuration in development.

# config/environments/development.rb

config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "127.0.0.1", port: 1025 }
config.action_mailer.raise_delivery_errors = false

Add mailcatcher in your development Procfile. There are similar gems out there, but mailcatcher fits me needs perfectly. 👌

# Procfile.dev
mail: mailcatcher --foreground

The --foreground switch keeps it running in same process and does not daemonize it into background. This way Foreman is able to stop mailcatcher process along with other processed defined in Procfile.dev.

Closing thoughts

This blog post is written entirely for me. This saves me from searching the answers from internet everytime I start a new project.

Some of thos snippets are very simple, but I cannot seem to memorize them into my brain. I still have to search bunch of simple stuff when programming. For example, the class that I need to inherit from when writing a unit test, I just don’t remember it.

By the way, it’s ActiveSupport::TestCase.

It's sounds like a perfect opportunity to write a FAQ for people who are new to internet domains!

Please note that Internet is in constant change. This blog post was written in early March in 2024. So if you're reading this in 2043, some details most likely are completely wrong.

What is Internet Domain Name?

Each computer connected to Internet (a.k.a. a server) has a IP-address. It's like a phone number. Your server has to have one, otherwise other computers cannot connect to it. Google and Facebook servers have IP-addresses. An IP-address is four numbers between 0-255, such as 130.231.240.1 which is the IP-address of University of Oulu, the birthplace of IRC.

Internet domain name is a human-friendly name for the IP-address. It's easier to remember Oulu.fi than 130.231.240.1. So when you type www.jomppanen.com in the address bar, the browser will ask from the DNS (Domain Name System) what's the IP-address for that address. The DNS replies with IP-address, and the browser opens a connection to the web server and you will see a website.

The DNS records contains over 359.8 million domain names (Dec 2023). That is a lot of domain names!

Why should a company own an internet domain?

A business needs a website. A business needs a brand. The internet domain name is a core building block for your brand. It is non-negotiable, you need it.

If you are building a business, you also need an email address. Don't use @gmail or @hotmail.com emails. It's bad for your professional credibility if you run your business as waynethehockeywizard99@gmail.com.

What are TLD's a.k.a. top-level domains?

When Internet was invented back in the day, there were only handful of top-level domains (TLD's), such as .com, .org, .edu, .mil. Since then, there are hundreds of TLD's with different kind of requirements. Pretty much all countries in the world have their own TLD, such as .fi and .ai, they are called ccTLD (country code TLD).

Some countries strike a gold mine with their TLD. Antigua from the Caribbean got $30 million dollar revenue in 2023 (reportedly!) from their country code TLD called .ai.

Like I said, there are hundreds of TLD's to choose from. But even in 2024, the best TLD (a.k.a. the part after last period) is still .com, try to get it and if it taken, go with other TLD's.

Where to buy a domain?

There are lots of domain registrars where to buy a internet domain, and their quality of service can be anything. I've owned domains over 20 years, and here are few my personal guidelines that I try to follow:

• Use several registrants - A cheap way to diversify the risk. If one of your registrants have problems, you still have other domains that you can operate.
• Hide your personal details - Pick a registrant that will hide your personal information from the DNS records. Never use your own personal email in the records, use a technical email such as domains@example.com.
• Registrant in same country - Try to pick a domain registrant that is located in same country as you, it makes things easier if you encounter any problems. Also, speaking a same language with your domain registrant is very helpful too.

The domain registrants that I have found to be good:

• Shellit.org - Located in Finland, speaks Finnish, so it's a great match for people living in Finland
• DNSimple - When the started, their target audience were programmers. Now they are bigger so their target audience is more generic. They are a bit more expensive than others.
• Namecheap - This is a big player, and they have a good tool for generating domain names, and the tool is free to use.

There are so many domain registrants all over the internet. Try "domain registrant" as keywords on your favourite search engine and add your city or country at the end of keywords. I would search for "domain registrant oulu" or "domain registrant finland" since I live in Oulu, Finland.

Remember, when you buy a domain you also have to renew it each year. If the domain is important to you, make sure that you have automatic renewal turned on and the payment goes through every year.

If you fail to pay for the domain at the end of billing cycle, you will lose it.

If you don't need the domain anymore, you can resell it or just let it expire.

What is a good domain name?

A good domain name is what your visitors remember even in their sleep. But the domain name itself is not the important part. Your website must provide enough value to your visitors, that they will type the domain on a mobile phone in the middle of Finnish winter, at -25°C.

When you are researching for possible domain names, and you find a domain name that has .com , .fi and .net available, don't hesitate for a second. Grab all three domain names. The most important TLD is .com.

Since there are over 390 million domain names, most likely your preferred domain is taken. If that is the case, then you have to get creative. Add a prefix or a postfix, or something. Back in the day, I came up with tinyinvoice.com since invoice.com was taken.

Don't get too creative. A good way to test if a domain name is good, is to explain it to your friends or family. Think about the difference between masterlist.fi and masterli.st, which one is easier to explain? Test the waters before buying it.

DNS is the system that runs Internet

The Domain Name System is the system that runs the modern world. It's the global phone book. If your computer or mobile device has a Internet connection, it can connect to DNS. It's a distributed system that has "nodes" all over the world.

The nodes are connected to root servers. There are 13 DNS root servers that are the authoritative source of trust for domain names.

When you buy a domain name, the domain registrant is responsible to inform the DNS about a new domain name. When you make any changes to DNS records of your domain (for example, changing a CNAME), it takes few moments for the information spread around all the nodes in the DNS. Sometimes it may even take 24 hours until the changes are propagated all over the world.

Most domain registrars and DNS services have a time-to-live (TTL) component for a DNS record. This number means that how many seconds the record is cached before the information is refreshed. If your TTL is set to 300, it means that any change you make to your domain DNS-records takes about 5 minutes (300 seconds / 60seconds) until the change take effect all over the DNS nodes on Internet.

If you know you are about to make big changes to your DNS records (changing email provider or web hosting service), you have to change the time-to-live to small number (i.e. 60 seconds) at least 24 hours before you start making the change.

When you're happy with your DNS-records and you're done changing them, it's good practice to set TTL to a higher number. For most cases, 24 hours is big enough number, 86400 in seconds.

Getting a website online

Ok, got the domain. It's a great domain! What next?

What you are looking for is a website hosting service. And like domain registrants, there are thousands and thousands website hosting services. There are global companies and there are local companies. They all offer the same service, connect a domain name with a website by editing A- or CNAME-records on the registrars website. They are part of your domain's DNS records and you have to edit the DNS records, otherwise your website does not work.

The web hosting service will provide you instructions for updating your DNS-records.

There are tools that you can use to check the DNS records. I use WhatsMyDNS to check that my A, MX, or CNAME records are set correctly for my domains.

Start small. Get bigger if you have the traffic. If you have 100 visitors per week, you don't need the beefiest service. Hundred visitors per week is such a low number that any kind of web hosting service can handle that easily.

There are services that combine a web design tool and a hosting service. They have their limits but it will get you started.

Website design & hosting services:

• Carrd
• Mmm.page

When you have a HTML+CSS files ready to go, then you are looking for a static website hosting:

• GitHub Pages - Host a static site for free (your website source code is available for everyone), your website is out there anyway, so it's not a big problem.
• Surge - Another static site hosting
• Netlify - Netlify is a static website hosting company that offers their own services to build dynamic components.

Buy your domain and website hosting from two different companies. Keep them separate and you have more flexibility.

If possible, make sure that your website has a function or a meaning. It might be a newsletter sign-up form, or buying a SaaS subscription. It can be anything.

Most cases it's selling or marketing, that's how you grow your business.

If your website has a function, it usually means that the website has a call to action (CTA) that you hope your website visitors perform.

Notice how I did not mention WordPress, SquareSpace or Webflow. They are very good tools in some cases, but not when you're building the first version of the website. Speed is the key, launch fast.

Sending and receiving emails on an internet domain

Next step is to send and receive emails on your internet domain. Your domain has MX-records, (mail exchanger records) that will the tell email service where to deliver the emails. When you buy a domain, you can edit the DNS records (MX-record too!) of your domain via the registrars service.

• FastMail - FastMail allows you to have one mailbox and multiple email domains and aliases.
• ProtonMail - Allows one mailbox and one custom email domain
• PurelyMail - Really cheap, they offer only email
• MailBox.org - German, Secure, multiple aliases

Remember, your email is the number one threat vector for cyber criminals. Use long passwords, and use two-factor authentication for extra security.

Also, do not write your email address as plain text on a webpage. The email spammers have automatic email address scrapers that will grab your plain text email from your website into the spammer's email list. It's a sure way to be on the receiving end of a spam email. Use a contact form or write your email address on a image and put that on the website if you want to share your email address.

Final words

I hope this article answers your questions on internet domains and websites. Just do it! Get a domain, build a website, acquire visitors! 💪

To help you get started, you can follow the checklist below.

Checklist for a website with own custom domain:

Like that check list? Go check out MasterList, my task management tool to-do app.

The database will be placed in vendor/postgres* folder depending on your PostgreSQL version.

Create the database

Find out your local PostgreSQL version

$ postgres --version
postgres (PostgreSQL) 14.8

Create local database for Postgres

$ pg_ctl init -D vendor/postgresql<version>

Create the database inside your Ruby on Rails project

Start PostgreSQL on your terminal. After you have it running, open another terminal window and perform the other steps.

$ postgres -D vendor/postgresql14.2/
2023-08-19 18:09:38.097 EEST [22144] LOG:  starting PostgreSQL 14.8 (Homebrew) on aarch64-apple-darwin22.4.0, compiled by Apple clang version 14.0.3 (clang-1403.0.22.14.1), 64-bit
2023-08-19 18:09:38.099 EEST [22144] LOG:  listening on IPv6 address "::1", port 5432
2023-08-19 18:09:38.099 EEST [22144] LOG:  listening on IPv4 address "127.0.0.1", port 5432
2023-08-19 18:09:38.099 EEST [22144] LOG:  listening on Unix socket "/tmp/.s.PGSQL.5432"
2023-08-19 18:09:38.101 EEST [22145] LOG:  database system was shut down at 2023-08-19 18:09:35 EEST
2023-08-19 18:09:38.102 EEST [22144] LOG:  database system is ready to accept connections
...
...

Setup database users for your project

Create a superuser for your database

$ createuser postgres -s

Create an user for your local development and use password password.

$ createuser localdev -d -P

Setup database configuration on Ruby on Rails

Depending on your PostgreSQL access control configuration, you might need to set username and password configuration to your config/database.yml file.

# config/database.yml

...
...

development:
  ...

  # Add these two lines
  username: localdev
  password: password
  ...

test:
  ...

  # Add these two lines
  username: localdev
  password: password
  ...

Create databases for development and test environments

Run Rails task to create the databases. If you see following output, databases for development and test environments were created successfully.

$ rails db:create
Created database '<rails_project_name>_development'
Created database '<rails_project_name>_test'

Add PostgreSQL to your Procfile.dev

Add the following line to Procfile.dev

# Procfile.dev

db: postgres -D vendor/postgresql<version>

Configure Git to ignore the development databases

Add this following line to .gitignore and commit it to your repository. This way your database will not be commited to the git repository.

# .gitignore

/vendor/postgres*

The Last Step

Finally, start your Rails development engine and you’re good to go!

$ bin/dev

This short guide will install PostgreSQL database on your local Ruby on Rails development environment.

The database will be placed in vendor/postgres* folder depending on your PostgreSQL version.

Create the database

Find out your local PostgreSQL version

$ postgres --version
postgres (PostgreSQL) 14.2

Create local database for Postgres

$ pg_ctl init -D vendor/postgresql<version>

Setup database superuser

Start PostgreSQL on another terminal. You have to have PostgreSQL running in order to perform the following steps.

$ postgres -D vendor/postgresql14.2/
2022-06-11 09:10:20.723 EEST [43595] LOG:  starting PostgreSQL 14.2 on aarch64-apple-darwin21.3.0, compiled by Apple clang version 13.0.0 (clang-1300.0.29.30), 64-bit
2022-06-11 09:10:20.725 EEST [43595] LOG:  listening on IPv6 address "::1", port 5432
2022-06-11 09:10:20.725 EEST [43595] LOG:  listening on IPv4 address "127.0.0.1", port 5432
...
...

Log in to PostgreSQL

$ psql -p 5432 -h localhost -d postgres

Create Superuser in Postgres

$ CREATE USER postgres SUPERUSER;
$ \quit

Setup databaser user for your project

Create portal user for local development and use password password12.

$ createuser localdev -d -P -s

Setup database configuration on Ruby on Rails

Depending on your PostgreSQL access control configuration, you might need to username and password configuration to your config/database.yml file.

# config/database.yml

...
...

development:
  ...

  # Add these two lines
  username: localdev
  password: password12
  ...

test:
  ...

  # Add these two lines
  username: localdev
  password: password12
  ...

Create databases for development and test environments

Run Rails task to create the databases. If you see following output, databases for development and test environments were created successfully.

$ rails db:create
Created database '<rails_project_name>_development'
Created database '<rails_project_name>_test'

Add PostgreSQL to your Procfile.dev

Add the following line to Procfile.dev

# Procfile.dev

db: postgres -D vendor/postgresql<version>

Configure Git to ignore the development databases

Add this following line to .gitignore and commit it to your repository. This way your database will not be commited to the git repository.

# .gitignore

/vendor/postgres*

The Last Step

Finally, start your Rails development engine and you’re good to go!

$ bin/dev

Terminology:

• SEO means search engine optimization
• A web crawler is an automatic tool that crawls through the internet and analyses the content of every page that it can find, and stores that into a database, also known as indexing (i.e. Googlebot, Bingbot)
• A search engine is a web page/product that searches that indexed database using the keywords from the user (Google, Bing, Duckduckgo)

SEO Analysis Tool

First, you need an SEO analysis tool. The internet is filled with online and offline tools that analyze your website from every possible aspect. Search engines are your friends, just search for “SEO Tool” and you will a lot of tools.

I’m using a browser extension called Detailed SEO Extension for simple SEO analysis. I don’t need a huge set of features, I just need the basic things and this extension does exactly that. You click a button and it gives you the current situation in an easily digestible version. Just head over to Detailed SEO Extension for the browser extension.

This is how it looks like when I analyze my Micro-SaaS landing page.

HTML Meta tags for SEO and Social

When the link to your page is shared in Facebook or Telegram, it shows the link preview/thumbnail. That information comes from OpenGraph tags or Twitter card tags. Luckily Twitter understands OpenGraph, so I’m not using Twitter cards.

The minimal opengraph / twitter card tags looks like this:

<meta property="og:title" content="Yesno.email - Ask simple questions via email from your friends and colleagues">
<meta property="og:description" content="Send simple yes/no questions with Yesno.email -- No more back and forth emails, send one email and get your question answered. When everybody has answered the question or the question expires, you will get a report with results and individual answers.">
<meta property="og:image" content="">
<meta property="og:url" content="https://www.yesno.email">
<meta name="twitter:card" content="summary_large_image">

Description tag

When your site appears on the search engine results page, the description tag in the HTML head is what is shown to the user. This piece of text is very important since it plays a major significance if a user clicks the link and lands on your website. The description cannot be too short or too long, many SEO tools say 70-120 characters is the optimal length.

This is a very important line of HTML, give it some thought.

<meta name="description" content="Ask simple questions via email from your friends and colleagues and get them answered! Yesno.email">

Canonical link

The canonical link tells the search engine the location of the original version. In this case, there are no other copies of the site or the content, the site-wide canonical link structure is very simple. Just set the canonical link to point to the same page.

Just put this line in your application.html.erb and your canonical links are in order.

<link rel="canonical" href="<%= url_for(only_path: false, protocol: :https) %>" />

Header-tags

Just use one <h1> tag per page. It’s the main header of your page and search engines use headers when they are indexing the page.

After you are happy with <h1>, next step is to put kick ass <h2> in place.

Robots.txt

Robots.txt is a file that provides information about your site to web crawlers. If you don’t want to index a certain part of your site, specify it in the file.

In yesno.email, there are a few routes that web crawlers have no business crawling. It has a path http://yesno.email/answers/* that is the route for an active question. When a user opens that route, the answer is registered for a question and the path goes inactive. This is the core functionality of yesno.email. If crawlers start hitting the route, it may potentially mess up an active question.

The disabled route in robots.txt is not enough protection. Yesno.email uses a gem called browser to detect crawlers in controllers. This is the only way to block email clients who are prefetching links on an email.

My robots.txt also contains the full path to the sitemap file.

# robots.txt

User-agent: * Disallow: /answers/*
User-agent: * Disallow: /confirmations/*

Sitemap: https://www.yesno.email/sitemap.xml.gz

Sitemap

Sitemaps are XML documents that describe the structure of your site for web crawlers. The larger your site is, the bigger benefit you will get from well-defined sitemap file. Sitemap file has useful information to web crawlers, i.e. the update frequency of a page. You can tell web crawlers to crawl a page every day or even every hour. Very useful if you have a page that changes multiple times per day.

You need line this in your app/views/layouts/application.html.erb

<link rel="sitemap" type="application/xml" title="Sitemap" href="/sitemap.xml.gz" />

A gem called sitemap_generator makes things easier. It creates a sitemap file in public/sitemap.xml.gz that is built according the rules in config/sitemap.rb.

After you have installed the gem, you can refresh your sitemap and automatically ping the web crawlers to crawl your site.

$ rails sitemap:refresh

In '/Users/tuomas/Projects/src/yesno/public/':
+ sitemap.xml.gz                                           2 links /  342 Bytes
Sitemap stats: 2 links / 1 sitemaps / 0m00s

Pinging with URL 'https://www.yesno.email/sitemap.xml.gz':
  Successful ping of Google
  Successful ping of Bing

Summary

Search engines and web crawlers improve constantly. In 2021, there are no dirty tricks or easy victories in SEO. The best way to get traffic from search engines is to write content that provides value to visitors. The foundation of the worldwide web still is the same, it’s the hyperlinks. It is the clearest signal for web crawlers and search engines. When a site links to another site, it is a vote of confidence and authority. The more links you have to your page, the better changes it has to end up on the search results page on certain keywords.

The SEO work I did for yesno.email takes a while to affect. The site is very small, and there is no extra content that the crawlers could index. Without any additional content, I don’t expect huge traffic through search engines.

Search engine optimization is important, but it’s still a tool in your toolbox. The better you know your target audience, the better results you get from SEO. What is the problem of your target audience? Do they use search engines when they are learning how to solve that problem? If they use search engines, what kind of keywords they use? If you know the answers to these questions, everything becomes a bit easier, even SEO. 😉

To save time the next time, I decided to document my setup for future reference.

How I write code

Vim

I started with empty vimrc and slowly adding stuff I need. I’m using just a couple of plugins (Nerdtree, ctrlp, supertabl, vim-endwise). Very minimal Vim setup.

Too bad I’m also using Sublime Text, so I probably don’t reach the higher levels of Vim mastery.

Vim

Sublime Text

The reason why I use Sublime Text instead of VSCode is the speed. Sublime Text launches almost as fast as Vim. For a color scheme, I’m using Monokai.

Sublime Text

Dash

Dash is my choice for documentation browser. The thing about Dash and other documentation browsers is the ability to store documentation offline, making it lightning fast to search for something.

I’ve configured Dash to open with Command-§, it’s the button just below Escape-key.

Dash

Fonts

I spend my days staring at text on my screen, so I want to optimize the font face for reading and writing code. Inconsolata and M+ are both monospaced fonts designed with great attention to detail and they are specially designed for reading and writing code. Both fonts match exactly what I need.

Inconsolata

M+ font family

How I listen to music

DI.FM

I stumbled upon DI.FM in ~2000 and kept listening to it occasionally during the 2000s. Back then DI.FM was called Digitally Imported. Turns out they are one of the first internet radios. They’ve been online since 1999!

A few of weeks ago, I found DI.FM again! I like the idea that a living person curates music instead of an algorithm so now I’m a happy paying customer.

DM.FM (Digitally Imported)

Spotify

I’m constantly contemplating discontinue my Spotify subscription. It plays music and that’s about it. That is the job I hire Spotify for. Spotify does not see it that way, as it wants to push features that I don’t need. As soon as a better alternative hits my radar, the threshold for a switch is very minimal and Spotify goes bye-bye.

I’m already a paying customer. Using paying customers to growth hack more users feel like a dark pattern.

How I take notes

Apple Notes

This is a disappointment. The internet is filled with great note-taking apps but I’ve settled to Apple Notes. I don’t even know what’s the official name for it, is it Notes.app or Apple Notes or maybe iNotes? Yet, Apple Notes fills 90% of my use cases. Maybe the note-taking apps are so commoditized, there are so few differences between them that I don’t need to look elsewhere?

I’ve used several note-taking apps, I did use Bear several years until I just found myself using Notes more than Bear. Bear is a great piece of software, I just gravitated more towards Apple Notes.

Bear

Numi

Numi is an interesting combination of a calculator and a notepad. It’s a calculator but on steroids. It’s becoming an integral part of my workflows since I can use variables and write long “notes” that are actually calculations.

I’ve configured Numi to open with Option-§, it’s the button just below Escape-key in the Finnish keyboard layout.

Numi

Other Apps

iTerm

The Mac OS terminal is really close to iTerm feature-wise, but iTerm offers a bit more features and configuration. I’ve configured iTerm to open Sublime Text when I click a text that resembles a full path of a file name, like in Ruby on Rails error stack trace.

iTerm

Rectangle.app

Rectangle allows me to move and resize windows with hotkeys. Very simple and useful app! I just have a couple of hotkeys defined, move the window to left-half or right-half of the screen.

Rectangle

TweetBot

TweetBot is the best! It shows me a timeline without suggested tweets or ads. It only shows content from accounts that I follow. It makes Twitter feel like it’s 2010 again.

Tweetbot for iOS Tweetbot for Mac OS

Homebrew

Does not need any introductions, it’s the package manager for Mac OS.

Homebrew

Oh My Zsh

I just installed Oh My Zsh and without any configuration, I got a command-line prompt that shows Git status (branch!) and Git completion. No extra configuration was needed!

Oh My Zsh

VLC (VideoLAN Client)

I mostly use VLC to play DI.FM internet radio channels. I’d like to think that VLC (which is a native application) eats less battery than a browser playing DI.FM stream.

VideoLAN is a non-profit organization that develops VLC and related products. It was founded in 2009. The project originally started in 1996 as a student project and it’s been an open-source project since 1998.

VLC

F.lux

F.lux keeps me to sleep better. It adjusts the color temperature of my screen to match with my local time. It tints my screen red during the evenings, so my brain thinks we’re getting closer to bedtime. Brilliant!

I’m not sure how effective it is, but I have no plans living without F.lux.

F.lux

I use Devise as my authentication library. I consider it the de facto authentication solution, at least until Ruby on Rails introduces an authentication solution that is built into Ruby on Rails.

I have been thinking about this subject for months, but this tweet by Ben Orenstein was the final push to get me into writing mode.

“Has anyone written something great about how to model your Rails-based SaaS app with Users, Teams, Organizations, and Subscriptions so that you don’t regret it later?”

A link to the original tweet

Users and Organizations

The Organization is a model that is at the core of everything. Every User will be a member of an organization through an association called Membership.

When a user is created by Devise, it creates an organization and membership and associates all of these three together.

The day will come when you need to associate your users in organizations and it will be the refactor from your worst nightmares. You will be better off by just associating organizations and users from the beginnings of your project.

Base Controllers

I like to use two different controllers for guest users and logged in users, ApplicationController is used for users who are not signed in and SignedInApplicationController is used when I want to restrict the controller only for users who are currently signed in.

ApplicationController is as plain as possible.

# app/controller/application_controller.rb

class ApplicationController < ActionController::Base

  protected
    def after_sign_in_path_for(user)
      designs_path(user)
    end
end

SignedInApplicationController has a larger set of responsibilities. It exposes two helper-methods, current_user is a Devise method and current_organization is defined here. It also forces to use a specific layout for signed-in users.

# app/controller/signed_in_application_controller.rb

class SignedInApplicationController < ActionController::Base
  before_action :authenticate_user!
  layout "signed_in_application"
  helper_method :current_organization
  helper_method :current_user

  protected

    def current_organization
      @current_organization ||= current_user.organization
    end
end

Namespacing models and controllers

I like to put models and controllers into namespaces when if they share similar responsibilities. Authentication and accounts prime candidates for namespacing and putting the files into subfolders.

As I mentioned, I am using Devise as go-to my authentication library. It works perfectly and does everything I need. I just override the create-method in registration controller, because I want to create Organization and Membership at the same time when User is created.

Directory structure

controllers
  app/controllers/authentication/registrations_controller.rb

models
  app/models/accounts/user.rb
  app/models/accounts/organization.rb
  app/models/accounts/membership.rb

The connection between User and Organization uses a conditional scope that returns only active memberships. This is a safety mechanism built into has_many association method organizations to allow access only if membership is active.

# app/models/accounts/user.rb

class Accounts::User < ApplicationRecord
  devise :database_authenticatable, :registerable, :recoverable,
         :rememberable, :validatable, :confirmable, :trackable

  has_many :memberships
  has_many :organizations, -> {where(accounts_memberships: { status: 0})}, through: :memberships
  has_many :all_organizations, through: :memberships, source: :organization

  def organization
    # for now, just assume that user has membership with
    # only one organization
    organizations.first
  end
end

Creating an organization when user-record is created

There are a couple of ways to achieve this. I like to create the organization-model in the registrations controller.

The code here below is copied from my latest project. If you want to use this, please do not copy it from here. Instead, go to Devise repository , find the registrations_controller.rb file and copy it from there. The create_user_organization_and_membership method does not necessarily need to be in the controller. You can put it into a separate file and make it as a model or a service object, whatever feels right for you.

# app/controllers/authentication/registrations_controller.rb

class Authentication::RegistrationsController < Devise::RegistrationsController
  def create
    build_resource(sign_up_params)

    # here is where the user-model is created
    create_user_organization_and_membership(resource)

    yield resource if block_given?
    if resource.persisted?
      if resource.active_for_authentication?
        set_flash_message! :notice, :signed_up
        sign_up(resource_name, resource)
        respond_with resource, location: after_sign_up_path_for(resource)
      else
        set_flash_message! :notice, :"signed_up_but_#{resource.inactive_message}"
        expire_data_after_sign_in!
        respond_with resource, location: after_inactive_sign_up_path_for(resource)
      end
     else
       clean_up_passwords resource
       set_minimum_password_length
       respond_with resource
     end
   end

   protected
     def after_inactive_sign_up_path_for(user)
       pending_confirmation_path
     end

     def create_user_organization_and_membership(user)
       return false unless user.valid?
       ActiveRecord::Base.transaction do
         user.save
         organization = Accounts::Organization.create(status: "active", name: user.email, created_by: user.email)
         membership = Accounts::Membership.create(organization: organization, user: user, role: "owner")
       end
       user
     rescue ActiveRecord::RecordInvalid => e
       # would be good idea to log the error message
       user
     end
end

What about payments and subscriptions?

When thinking about responsibilities in this architecture, the responsibility of holding the information if somebody has paid or not belongs to Organization.

The Subscribeable concern has the logic to determine if an organization has a payment subscription or not. It also has the functionality to start and end a subscription.

In my case, it contains free-trial functionality and requires a subscription after the free trial ends. Requiring the credit card in the registration process is a bit tricky in the EU with strong-customer-authentication (SCA) regulation.

I like to put payments into their own namespace. All related code lives in payments namespace. Payment processor related code lives in their own directories, for example app/models/payments/processors/stripe_processor.rb

Organization-class includes Subscribeable concern.

# app/models/accounts/organization.rb

class Accounts::Organization < ApplicationRecord
  include Payments::Subscribeable

  ...
end

Closing words

When creating something larger than “Hello World”, things get complicated quickly. The term “it depends” is used more and more. Any blog post written about software architecture can be read with a grain of salt. So pleas remember, this is just one way of architecting a SaaS user management.

If this approach feels a bit too limited for you, head over to FireHydrant blog and read this blog post by Bobby Tables.

I would greatly appreciate it if you kindly give me some feedback on blog post!

If you have ideas on how to handle the generic-part of the architecture of a SaaS, please send me an email or tweet at me. I’m always looking to improve my skills and knowledge!

Any kind of feedback is appreciated! My email is

My earliest memory related to programming goes way back into the 80’s. I was with my cousin, playing with He-Man figures. Obviously, we needed a portal. We tried to make it with pen and paper but there was nothing cool about it, it was a portal after all. Portals need to be cool.

I realised that if I would turn on my computer and change the background color, it would be a cool portal. Naturally, after few minutes, I wanted to change it constantly. That was probably the first time I wanted to read a book to actually learn something. It’s a good thing that Spectravideo 328 had pretty good Basic-manual. After reading through the manual I made a animation with for-loop and I had a portal beyond any coolness! I think I was about 10 year old back then.

The List of Programming Languages

Here is a list of programming languages I’ve had pleasure to work with. Since I learned programming it has been my hobby ever since, I don’t think there is a week that I haven’t written at least few lines of code.

Basic Programming Language

My first computers were Spectravideo 328, Spectravideo 728 and Commodore 64. I never got into anything more powerful, Basic programming language is what I was using. Newer tried Commodore 64 Assembler, even that was the thing the cool kids used.

Thank You Spectravideo for doing awesome job on the manuals. I thought myself programming from a books written in foreign language (English) in a method that pretty much looked like the method Zed Shaw used in his programming books.

I also used Basic when I got Atari 512 and STOS. It was an development environment built for making games. You have no idea how cool it was back then. Of course next year they released AMOS for Amiga and it had no line numbers! How you can write programs without line numbers?

My options were Atari ST and Amiga 500. The sales person in Atari-shop was so convincing with some image editor. It was so convincing that I didn’t even want to see what Amiga 500 could do…

Turbo Pascal

I got my first PC and I got a copy of Turbo Pascal. Pascal did not use line numbers, it used functions and procedures! It had a lot of memory, I could load images into memory and use them as sprites. I was walking on a very steep path of game programming. I could reference a specific point in memory, read and write bytes into it, but back then, I really did not find any use for it. I did my pixel drawing with Turbo Pascal standard library. There was no internet, there was only few BBS’s where I could download tutorials.

This was about the time I got familiar with Demoscene. The intros and demos for Amiga blew my mind several times, and I tried to replicate the easiest effects with Turbo Pascal. Even the easiest effects seems to be out of my reach.

C/C++

After a while, I grew tired of restrictions of Turbo Pascal. I somehow got my hands on DJGPP and Watcom-products. C was a total beast, it could do pretty much anything! I could reboot my computer by using variables in a wrong way. I found out I did not need any libraries if I would like to draw pixels on screen, there was a certain point in memory where I could write data and it would show up on my screen instantly. Crazy!

I wrote my own Sprite-libraries, Polygon-drawing libraries, keyboard handling by using interruptions, all sorts of things are taken granted in 2010’s. One great thing about C was that I could use inline assembler to do really fast things. I could fill my screen with specific color with just few commands. (rep stosb)

I did intros, demos and really simple games that used 3D, but it was really hard to write 3D engine in C. That led to me to C++ and object oriented programming. A 3D engine was much easier to write by using objects that are linked to other objects, inheriting positions and rotations from parent objects. That was the way I learned object oriented programming, even thought I didn’t know the terminology at all back then.

Java

I was about 20 year old when I first me Java and JVM. First, it was really weird not having direct access to memory and let the JVM worry about deleting all unused variables. Eventually I got over it. I’ve never written any big programs with Java as a hobby, I’ve only written bigger Java projects at work. I wasn’t the biggest fan of Java back then.

I eventually ended up in a game company that did mobile games. The mobile phones back then were using b&W screen and there was just few kilobytes of memory. My C/C++ skills came handy when I had to squeeze Java programs into small memory footprint, especially fixed-point maths.

PHP

During my Java-phase, I also got interested in writing web sites. I tried Microsoft ASP but PHP was much easier to understand. I did web sites with PHP and eventually I ended up writing my own MVC-framework. It never got into production-quality level, since PHP had bit of problems back then that prevented me to do the things I wanted.

Python

From PHP, I jumped on board with Python because it had pretty cool game programming libraries (LibSDL). I tried web programming with few frameworks but somehow I didn’t get along with Python. Every time I got frustrated with Python I jumped back to PHP. After a while I got frustrated with PHP so I came back to Python. This happened many times.

Ruby

One day I saw video that blew my mind like Future Crew’s Second Reality. I watched a guy writing a blog with this magical programming language, using really cool framework. I was instantly hooked. Even the editor the guy used to write the code was mind blowingly simple and powerful.

I met Ruby, Ruby on Rails and Textmate at the same time, introduced by DHH. Like many Rubyist, I met Ruby through Ruby on Rails. I remember many times confusing functionality of Ruby on Rails with Ruby, but so what? Writing code with Ruby and Ruby on Rails was so much fun!

I remember the restful changes introduced in Ruby on Rails 1.2 and the big merge with Merb and Ruby on Rails. The biggest factor of my warm feelings to Ruby and Ruby on Rails is the community. There has been so many cool & weird people, that it would be unfair to list them all.

I’ve contributes to few Ruby open-source projects but my biggest contribution to Ruby community is Rubysauna, which we have been organising with @polarblau.

Javascript

Everything that can be written in Javascript, eventually will be written in Javascript. I’ve written a ton of Javascript, I’ve built a typography tool with Ville Vanninen that has been rewritten number of times. I have a suspicion that next rewrite will be with React.

Even Javascript is a language that, in past 10 years, I’ve most likely written most lines of code, I still don’t consider myself a Javascript developer.

Elixir & Go

Even though Ruby is my weapon of choice pretty much everything, I’ve got to know Go and Elixir a bit. I’ve spent enough time with both of them to understand why people like them.

With Go, I like how the libraries are compact but still really powerful.

Elixir has been huge in Ruby community. It’s built one of the Ruby legends. Elixir has taken the best part of Ruby and put Erlang VM underneath.

I don’t know what’s my next favourite programming language is, but in 2016, I consider myself as Ruby developer.