DLN.
Dev since 2011

Damian

Le Nouaille

Senior Ruby Developer & Speaker. Crafting high-performance web experiences with Ruby and modern standards. Read my story.

"Every line of code is a design decision. Every commit tells a story."

— DLN

From the Log

Selected Experiences

Localtower

Localtower - The first UI to manage your Rails DB migrations

2017

The New Dope (book)

In January 2019, after the surprising success of my blog post “Instagram is listening to you”, I felt the urgency to publish The New Dope. The goal of this book is to explain how the Web works and what are the potential dangers of technology on the long term

2019

"The system worked perfectly. I remember debugging the last feature in the airplane, offline, during the flight from Paris to New York."

— DLN, on FIFA FIWC

Typography

Building for the Web

Crafting Experiences

Tools of the Trade

Technical Details

After 15 years of crafting web applications, I've come to believe that the best code is the one you don't have to think about. It works, it's tested, it's elegant. The architecture should serve the product, not the other way around. Every decision matters—from the database schema to the deployment pipeline.

I write Ruby because it reads like prose. I choose Rails because conventions matter more than configuration. I test first because confidence compounds. And I deploy continuously because shipping is the only metric that counts.

"The system worked perfectly, and it was a huge success. I remember debugging the last feature in the airplane, offline, during the flight from Paris to New York."

— From the FIFA FIWC experience
app/services/application_service.rb
class ApplicationService
  def self.call(...)
    new(...).call
  end

  private

  def success(data)
    { success: true, data: data }
  end
end

Use ApplicationService as a base class. Links look like this example and use bold text or italic text for emphasis.

terminal
$ bin/rails db:migrate
== 20260118 CreateUsers: migrating ===
-- create_table(:users)
   -> 0.0042s
== 20260118 CreateUsers: migrated ====

$ bin/rails test
42 runs, 128 assertions, 0 failures, 0 errors
app/models/user.rb
class User < ApplicationRecord
  has_many :projects, dependent: :destroy
  validates :email, presence: true,
                     uniqueness: true

  def display_name
    "#{first_name} #{last_name}"
  end
end
  • ~ Ruby on Rails for rapid, reliable web applications
  • ~ PostgreSQL with carefully designed schemas
  • ~ Test-driven development as a daily practice
  1. 01. Understand the problem deeply before writing code
  2. 02. Design the data model and service boundaries
  3. 03. Write tests, implement, deploy, iterate

Hand-drawn Elements

The Artisanal theme embraces imperfection. Rough.js creates sketchy borders, CSS provides wobbly border-radius, and SVG illustrations draw themselves in as you scroll.

Rough.js sketchy rectangle

CSS hand-drawn border

This card uses pure CSS asymmetric border-radius to create a hand-drawn feel. No JavaScript required.

SVG sketchy underline

A hand-drawn underline

Rough.js decorative circle

Animated SVG — Ruby gem (draws on scroll)

Animated SVG — Deploy rocket (draws on scroll)

Animated SVG — Terminal prompt (draws on scroll)

"Ruby reads like prose. Rails lets you ship like a poet with a deadline."

— DLN

Approach

Architecture

Service objects, clear boundaries, and conventions over configuration. Every Rails app I build follows the same proven patterns.

Testing

Test-driven development isn't a methodology for me — it's muscle memory. Every feature starts with a failing test.

Performance

N+1 queries, missing indexes, slow background jobs — I've debugged them all. Performance is a feature, not an afterthought.

Shipping

CI/CD pipelines, Docker deployments, zero-downtime releases. The best code is the code that's running in production.