DEV Community: Marco

Update 3: Kamal + Postgres Finally Running

Marco — Mon, 16 Feb 2026 03:02:51 +0000

I finally configured Kamal to work with Postgres. It took a few days of trial and error — until now I had only used SQLite, which is great for a tiny MVP, but not enough once things start growing... or this is what I am told myself for learn how to configure it :D

Here’s the accessory config I’m using in deploy.yml:

accessories:
  postgres:
    image: postgres:15
    roles:
      - web
    env:
      clear:
        POSTGRES_USER: "postgres"
        POSTGRES_DB: retro_production
      secret:
        - POSTGRES_PASSWORD
        - POSTGRES_USER
    directories:
      - data:/var/lib/postgresql/data
    files:
      - config/init.sql:/docker-entrypoint-initdb.d/setup.sql

Useful commands:

Boot Postgres
kamal accessory boot postgres

Check if it’s running
kamal accessory details postgres

Few post I used for learn this:

https://deploymentfromscratch.com/kamal/running-postgresql-on-kamal/
https://rameerez.com/kamal-tutorial-how-to-deploy-a-postgresql-rails-app/

A Small Lesson I Learned the Hard Way

Marco — Mon, 02 Feb 2026 13:25:11 +0000

A few years ago, I was juggling a big project at work, moving from Italy to the US, and rebuilding my life from scratch. In the middle of all that, something simple—but brutal—hit me: back pain.

I kept working, of course, and I mentioned it to my team lead at the time, Ivan. Today I see him as a real mentor. He told me something I’ll never forget:

“Spend as much on your chair as you spend on your computer. I learned it the hard way, just like you’re learning it now.”

He pointed me toward the well‑known brands—Steelcase, Herman Miller—and warned me not to trust cheap chairs to do the same job.

I’ve always struggled with spending money on myself, so seeing chairs that cost thousands of dollars scared me. But after some research, I found companies that refurbish these high‑end models. They explained their process, the quality, and the savings. I took the leap.

I paid less, got a great chair, and my back pain disappeared for years.
Now that it’s creeping back, I’m reminded again how much our work depends on our bodies being able to support us.

The short version
If you’re early in your career, please take care of your body.
You can study hard, code all day, push yourself—but you also need movement, rest, and a setup that doesn’t slowly break you.

Your future self will thank you.

I hope this small experience helps someone out there.

Build in public day 1 - Dealing With “Magic” in Frameworks

Marco — Thu, 22 Jan 2026 13:36:28 +0000

I’m working on a small project right now. Nothing revolutionary, but it works, it’s fun, and it has some interesting features.

Most of my career has been on the frontend, but I’ve also worked with Django, FastAPI, and sometimes Rails.

Rails has a very particular approach based on “magic.”

And I don’t mean “magic” only in a good way. I mean the kind of magic where things work… but you don’t fully understand why they work, because the framework hides a lot of complexity. This happens with many tools. jQuery was the first “don’t worry, I’ll handle it for you” library I used early in my career.

Hiding complexity is great, but it also requires skepticism, testing, and validation—things you don’t need as much when you build everything from scratch.

A Practical Example: Deploying With Kamal
For deployment, I used Kamal. Kamal handles a lot for you: server setup, deploy configuration, even SSL certificates. It’s a sweet deal—but you need to learn Kamal and trust Kamal.

Here’s a simple example of the configuration it requires:

service: retro

# Name of the container image.
image: registryUser/retro # <-- your docker username/project name

servers:
  web:
    - 0.0.0.0 # <-- your server IP

proxy:
  ssl: true
  host: retro.ponopo.site

registry:
  server: localhost:5555
  username: myusername # <-- your docker username

env:
  secret:
    - RAILS_MASTER_KEY

volumes:
  - "db_storage:/root/storage"

Just a few lines, and Kamal will SSH into your server and set everything up. Magic!

When the Magic Breaks

Then I discovered a big bug in my production configuration.
So I had to slowly “unpack” the magic and understand what was really happening.

That led me to learn how to run Rails in production mode locally.

Here are the commands I used:

Create the production database

RAILS_ENV=production rails db:create

Run migrations

RAILS_ENV=production rails db:migrate

Precompile assets

RAILS_ENV=production rails assets:precompile

Start the server in production mode

RAILS_ENV=production rails s

Thanks and see y'all soon

Building in Public - Day 0

Marco — Thu, 22 Jan 2026 13:18:01 +0000

My brain freezes every time I think about publishing the first MVP.
It’s definitely not ready. And after 14 years working on the web, it’s not easy to ship something incomplete, not polished, or somehow perfect.

What perfect even means?

Perfection means something different to everyone : perfect CSS, perfect JavaScript, perfect load times, perfect interactions, perfect engagement.

This project is none of that. It’s just the result of a few late‑night hours stolen from sleep.

I’m terrified, but I want feedback. That’s what pushed me to write this post.

I want someone to tell me what they think—even if it’s harsh. I need that input, and I’ll deal with it, even if it stings.

I’ve worked hard to compress the complexity so this could be a one‑person project: backend, frontend, and now this post. I learned this idea from a talk about Ruby on Rails, and it stuck with me.
I used Copilot like having a friend junior developer while I am reviewing every line before committing it to the repo.

They’re my commits because I believe I’m responsible for every line. I can’t blame AI for a bug—if it’s there, it’s because I didn’t check carefully enough.

So here’s where I am now:

I built the first MVP of my project.
Now I need the courage to deploy it and ask a few friends for feedback. This step turned out to be harder than I expected, but I’m hoping this post gives me the push I need to move forward.

Notes on Rails

Marco — Fri, 10 Oct 2025 20:53:24 +0000

I solved few errors and I want here to provide how

esbuild and sass missing

Running bin/rails test:system

The error message contains

sh: esbuild: command not found
bin/rails aborted!
jsbundling-rails: Command build failed, ensure `npm run build` runs without errors
sh: esbuild: command not found

As suggested npm run build is a good start
and it show this error message

sh: esbuild: command not found
bin/rails aborted!
jsbundling-rails: Command build failed, ensure `npm run build` runs without errors

the solution is install esbuild, I also suggesto to install sass if you are not sure

npm install --save-exact --save-dev esbuild sass

Running npm run build:css

I see this error:
sh: sass: command not found

the solution is install sass, I also suggesto to install esbuild if you are not sure

npm install --save-exact --save-dev esbuild sass

now npm run build:css and npm run build works and I can finally run my tests

# Running:

Capybara starting Puma...
* Version 7.0.4, codename: Romantic Warrior
* Min threads: 0, max threads: 4
* Listening on http://127.0.0.1:63406
....

Finished in 2.813492s, 1.4217 runs/s, 3.9097 assertions/s.
4 runs, 11 assertions, 0 failures, 0 errors, 0 skips

Browsers

Marco — Mon, 19 May 2025 15:39:25 +0000

What's a web browser?

... serioulsy what's a browser?

I would define a browser as an ecosystem of multiple interpreters with the goal o presenting a web page.

An interpreter?

Yes, like Python, Lua ... Uh no... sorry not like that... since the those interpreters are not afraid to show that you made a error while a browsers hide your errors

A good browser is a browser who can work with partial, missing, buggy infomations

Here is a simple example

<HTML>
    <HEAD>
    <BODY>
<h1>hi All

This code not only works without errors but also get fixed in realtime in this, without any alert of error :

<html><head>
    </head><body>
        <h1>hi all</h1></body></html>

A browser is a ecosystem of interpreters who call is to show a web page whatever is buggy, full of problem ... the browser will show something if he can ... it will triggers an error as last last last thing before trying anything to fix it.

Let me add here an other point... the browsers are multiple each one with different interpreters for the same language. Nowadays most of the browsers are based on Webkit but still not all browswer and they do still have custome codes.

Each browser may have some differences from on to another

That's ok... we can still make great apps if we know what we are facing.

This is a series of post that I decided to do about web and technology... I hope you enjoy it

Exploring the Instructor Library: Structuring Unstructured Data (and Some Fun along the Way)

Marco — Sat, 16 Nov 2024 14:40:45 +0000

I’ve recently come across the instructor library, and I have to say, I’m pretty impressed. The concept of structuring unstructured data is both powerful and, dare I say, a bit magical. The idea that you can take data that’s all over the place and somehow impose order on it—well, that’s just my kind of wizardry.

But… how exactly does it work?

To find out, I spent some time digging into the internals of this library, and I discovered that there are two key players behind the scenes that are responsible for much of its magic.

Meet the Players: Pydantic and a nice prompt


import instructor
from pydantic import BaseModel
from openai import OpenAI

Now, if you're familiar with Python's data validation and settings management, you’ve probably heard of Pydantic. And if you haven't... well, buckle up! It’s an amazing library that allows you to define data structures and then validate that incoming data matches those structures—in real time. Think of it as the bouncer at a fancy club, making sure that only the right data gets in.

FastAPI, which is another great tool, makes excellent use of Pydantic to ensure that data passing through an API is in the right format. So, what's the next step? Now that we’ve defined our structure, how do we get an LLM (like OpenAI’s GPT) to follow it? Hmm…

Hypothesis 1: Pydantic's Serialization

My first hypothesis was that Pydantic might allow some kind of serialization—converting the data structure into something an LLM can easily understand and work with. And, it turns out, I wasn’t wrong.

Pydantic allows you to serialize your data into a dictionary with the following method:

model.model_dump(...)  # Dumps the model into a dictionary

This method recursively converts your Pydantic models into dictionaries, which can then be fed into an LLM for processing. So far, so good. But then I stumbled across something even more interesting:

Hypothesis 2: Generating a JSON Schema

It gets better. Pydantic doesn’t just convert data into dictionaries—it can also generate a JSON schema for your model. This is key, because now you have a blueprint of the structure you want the LLM to follow.

Here’s where things really started to click:

# Generate a JSON schema for a Pydantic model
response_model.model_json_schema()

Bingo! Now you’ve got a clear schema that defines exactly how the data should look. This is the blueprint we can send to the LLM, so it knows exactly how to structure its output.

Bringing It All Together

message = dedent(
    f"""
    Understand the content and provide
    the parsed objects in json that match the following json_schema:\n

    {json.dumps(response_model.model_json_schema(), indent=2, ensure_ascii=False)}

    Make sure to return an instance of the JSON, not the schema itself
    """
)

Here, the library is passing the schema to the LLM, asking it to return data that conforms to that structure. The message is clear: "Hey LLM, respect this schema when you generate your output." It’s like giving your LLM a detailed map and saying, “Follow these directions exactly.”

Thanks for bear with me

So, after all this investigation, I’m now convinced: Pydantic’s serialization and JSON schema generation are what make it possible for the Instructor library to get an LLM to follow structured data formats.

Thanks for sticking with me through this fun (and slightly convoluted) investigation. Who knew that unstructured data could be tamed with a little help from Python libraries and a bit of creative prompting?

Quick and Dirty Guide to Running a Local LLM and Making API Requests

Marco — Sat, 16 Nov 2024 14:21:59 +0000

Alright, buckle up because we’re diving into a quick and dirty solution for running a local LLM (Language Model) and making API requests — much like what the fancy commercial solutions do. Why? Well, why not? In just about three minutes, you can have a perfectly decent system running locally for most of your tests. And if you ever feel the need to scale up to the cloud again, switching back is practically effortless.

Here’s the documentation we’ll be following, mostly so you can claim you’ve read it:

OpenAI API docs

In particular, we’ll focus on making a request like this:

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
     "model": "gpt-4o-mini",
     "messages": [{"role": "user", "content": "Say this is a test!"}],
     "temperature": 0.7
   }'

So far, so good, right? Nothing groundbreaking. But here’s where it gets fun…

Enter LM Studio

There's this gem of a tool called LM Studio, which makes local LLMs much easier to handle. After installing and running your model, you’ll notice a tab with a console icon called Developer. I know, it doesn’t sound too exciting at first, but hold on, because it gets better. This tab comes with a handy CURL example that shows you exactly how to use your local model. And, wouldn't you know it, it looks pretty familiar!

curl http://localhost:1234/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3.1-8b-lexi-uncensored-v2",
    "messages": [
      { "role": "system", "content": "Always answer in rhymes. Today is Thursday" },
      { "role": "user", "content": "What day is it today?" }
    ],
    "temperature": 0.7,
    "max_tokens": -1,
    "stream": false
}'

Looks pretty familiar, right? This is the local version of what we just saw. You get the same setup as the OpenAI API request, except it’s running on your local machine. Plus, it's got a little flair — like the "Always answer in rhymes" system prompt. Poetry, anyone?

What About Python? We Got You.

If you prefer working with Python (and let’s be real, who doesn’t?), here’s how you’d send the same request using Python’s requests module:

import requests
import json

url = "http://localhost:1234/v1/chat/completions"

headers = {
    "Content-Type": "application/json"
}

data = {
    "model": "llama-3.1-8b-lexi-uncensored-v2",
    "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"}
    ],
    "temperature": 0.7,
    "max_tokens": -1,
    "stream": False
}

response = requests.post(url, headers=headers, data=json.dumps(data))

if response.status_code == 200:
    result = response.json()
    print(result["choices"][0]["message"]["content"])
else:
    print(f"Error: {response.status_code}")

And voilà! You’re now ready to send requests to your local LLM just like you would with a commercial API. Go ahead, test it, break it, make it rhyme — the world (or at least your model) is your oyster.

Enjoy!

How-to: Use dictionary in TypeScript

Marco — Wed, 05 Jun 2024 20:42:11 +0000

Here is the scenario, I want to create a function getLegsNumber that use this structure as dictionary

const mappingAnimalLegs = {
    'CAT' : 4,
    'DOG' : 4,
    'DUCK' : 2
}

If I write something like this

function getLegsNumber(animal) {
    return mappingAnimalLegs[animal] | 0
}

Typescript is not happy and tell us:

Element implicitly has an 'any' type because expression of type 'any' can't be used to index type '{ CAT: number; DOG: number; DUCK: number; }'.(7053)

So... how I can solve this without adding too much noise ?

Here is my solution:

function getLegsNumber(animal: string): number {
  if (animal in mappingAnimalLegs) {
    return mappingAnimalLegs[animal as keyof typeof mappingAnimalLegs];
  }
  return 0
}

I can also simplify a bit more with

function getLegsNumber(animal: string): number {
    return mappingAnimalLegs[animal as keyof typeof mappingAnimalLegs] | 0
}

What do you think?

Typescript playground as reference

[WIP] Test UI?

Marco — Wed, 05 Jun 2024 20:31:14 +0000

There are different solutions on test UI

Jest unit testing
Jest Snapshots
Integration testing
Image comparison testing
Accessibility reports
Manual testing

When to us what? In my experience a big project will end up using all of them.

Let start with the first

Jest unit testing

Unit testing is a type of software testing that focuses on individual units or components of a software system.

Nice... but let also mention that:

we want to test behavior and not implementation

The goal is I can change 100% the implementation and the test will still pass

How? the style is called "Black box testing" and it focus on behavior not on testing each function input output

Jest Snapshots

As the official docs tell

Snapshot tests are a very useful tool whenever you want to make sure your UI does not change unexpectedly

The idea is, I take a copy of the rendered component ( only the generated HTML) in a scenario X and I will compare each time I run the test. If it's different... Well, we know something has changed

... to be continued

Test if a promise throw an Error

Marco — Wed, 05 Jun 2024 20:19:36 +0000

Hi, few weeks ago I had to solve this problem,

If the API return 404 I want my code to Throw and error, in general fetch will not throw an error on API failure with exception of a time out so I had to force that behavior:

Here is my base code

const response = await fetch(url);
 if (!response.ok) {
    if(response.status !== 404){
        throw new Error(`Error on details API ${response.status}`)
      }
  }

Ok... here the solution I end up with:

    await expect(
                api.fetchEvent(body)
    ).rejects.toThrow('Error on details API 404');

It can be improved but I thought sharing the solution may help somebody else

How to determine which Python version your Jupyter notebook is using

Marco — Fri, 09 Jun 2023 16:42:24 +0000

Have you ever spent an incredible amount of time trying to understand which version of Python your Jupyter Notebook is using, or how to install a library on it? The solution is actually quite simple.

All you need to do is run the following code block in your Jupyter Notebook:

import sys
print(sys.executable)
print(sys.version)
print(sys.version_info)

This will return information about the version of Python being used, as shown below:

/usr/local/opt/python@3.9/bin/python3.9
3.9.16 (main, Dec  7 2022, 10:15:43) 
[Clang 14.0.0 (clang-1400.0.29.202)]
sys.version_info(major=3, minor=9, micro=16, releaselevel='final', serial=0)

Ah!! Now everything is clear! You can also find pip3.9 in the /usr/local/opt/python@3.9/bin/ directory, and there is also pip3.9 that you can use to install library like :

/usr/local/opt/python@3.9/bin/pip3.9 install dotenv

Stay tuned for future improvements and next episodes on how to use an environment in Jupyter Notebook