DEV Community: Ruben Alvarado

Start with NvChad

Ruben Alvarado — Sat, 16 May 2026 19:48:34 +0000

Originally published on Web Warrior Toolbox

NvChad is a code editor that is light weight and can be used from terminal screens. It has a system of add-ons (e.g. lazy vim) that lets you add functionalities found in GUI like editors. If you have a server that has only CLI and you want a rich feature editor, use this. NvChad can also be practicall when you have a dev-pc that will run heavy loads while you need to use an editor at same time(serving a heavy app locally while running Figma, youtube someone?). Anyway give it a try so you have another editor that you can use in these scenarios or other that you think it could be worth it.

How to install (Linux PC)

the process to install has these parts

Install git. You will need to clone a git repo after that.

sudo apt update
sudo apt install git
git --version // check version

Install Neovim. you need version 0.10 or higher

sudo apt update
sudo apt install neovim
nvim --version // check version

install nerdfonts

mkdir -p ~/.local/share/fonts
cd ~/.local/share/fonts
wget https://github.com/ryanoasis/nerd-fonts/releases/latest/download/JetBrainsMono.zip
unzip JetBrainsMono.zip
fc-cache -fv

⚠️ Then set the font in your terminal emulator.

Clone the NvChad repo:

git clone https://github.com/NvChad/starter ~/.config/nvim

start nvchad

nvim

now when you access NvChad you can look at the file tree using space e to open it. Here some more commands to use with the tree

tab // expand/collapse a folder
E // expand folder and subfolder
CC // collapse folder and subfolders
H // show/hide hidden folders

and to move between panel use these commands

ctrl+w // window mode
ctrl+<direction_key> // use hjkl

To open and close terminal window use

alt + h // toggles horizontal terminal.

Tab > Window > Buffer

nvchad has these 3 elements to organize what is shown on screen

A buffer is a file loaded in memory. when you press enter on a file in file tree you open a buffer. Remember these commands.

in normal mode
:bd // close buffer (buffer delete)
:ls // get a list of buffers and its numbers
:b <N> // opens buffer with number N (space can be ommited)
tab // go to next buffer
shifht+tab // previous buffer

Windows and Tabs

A windows is an element that shows 1 buffer. use :q to close a window (you will also close the buffer it contains). Use :qa to close all windows (this closes nvchad)

A tab is an element that shows multiple windows. Here are some commands to manage them

:tabnew // create tab
:split // split with horizontal window
:vsplit // vertical split
:tabs // lists all tabs and windows

Be patient and keep practicing to develop your skills and muscle memory 💪🥘

Flexible Git Workflow - We Actually Use

Ruben Alvarado — Thu, 14 May 2026 18:42:48 +0000

Originally published on my blog Web Warrior Toolbox

In this article I write about the workflow we use on daily basis. This is a way to provide the team with simple and easy to understand rules that help them stay in order to have ready to deploy code bases. In this case, we are part of a team where 1 to 3 developers contribute to a code base. We make use of Gitlab and its issue boards to keep track of features. You can refer to these guidelines as a base and adapt for your own team. Be flexible and think about when the rules can be applied a when it is better to device new ways to solve your projects.

How we develop?

1. Listen to stakeholders and take notes

Start by speaking with stakeholders of the project and internal users from the team. This will give an insight of the the core features that define the application—(e.g. profiles, requests, and others). For each area, note the necessary changes and improvements for your project.

After condensing your meeting notes into general issues, you’ll notice that issues usually combine between frontend and backend development work. You can further divide general issues into more specific ones that correspond to back or front end so they can be assigned to a developer.

Example

General Issue: request form

Specific Issue: chevron arrow in select needs spacing (frontend).

Specific Issue: retrieve the select options from a database (backend).

2. Create Feature Branches

Now you have an issue board with general and specific issues. Each issue you create in a GitLab board is assigned a unique number. Use that number as a ticket reference in a conventional branch name. Create the branches you need from master branch or from a general branch as you see fit. You can use vscode extensions for conventional branches and conventional commits to simplify your life in this respect.

3. Merging Strategy: Keep It Simple

Now, regarding merging: keep it simple and merge what you consider makes the process easier to understand. Sometimes it's more practical to merge an specific feature (like chevron arrow spacing of the select element) directly to master. Other times it makes sense to merge it first to a more general branch to test it and make sure it can go to master without making the app crash.

Maintain a single major branch—master. Merge all features into master once they are deemed ready. This approach minimizes the number of Git commands developers need to remember and keeps the branch tree simple, reducing the learning curve for new team members.

4. Using Tags for Clarity and Safety

Use tags on master with version numbers to track what has actually been deployed to production (e.g. semantic versioning). Tags also serve as warnings: when a buggy commit is tagged, others can easily notice and avoid using that version.

Wrapping up

As you can see these rules are flexible and you can use them to evaluate what is worth keeping for your team and what is better to change. Designing a workflow is a continuous activity that can benefit your team by making communication more effective and accelerate the time it takes until production deployment. Since the best pattern varies from team to team, you need to keep notice of your particular conditions and customize the workflow to improve your development time to production.

MongoDB didn't start because of File permission issue

Ruben Alvarado — Fri, 27 Feb 2026 20:52:10 +0000

The Wired Tiger Turtle in the logs

Originalled published on Web Warrior Toolbox

A Wired Tiger Turtle Story...

While troubleshooting a project, I wanted to run the db locally before deploying my hotfix. I set my pc for that and I mocked a database with some useful data for my test before deploying to production that day.

Two days later a new issue that needed a hotfix came to me and I needed to test again with a local database. I tried to start the db with the usual command systemctl start mongod but I saw it didn't start when I checked with systemctl status mongod.

When I checked status I saw a message saying that it didn't start but i couldn't understand the reason why.🤨

After following multiple suggestions from chatbots and getting lost myself 😵‍💫 I understood that the answer to that question was in a place I didn't use to look at 💬: THE LOGS! 🪵

In Linux you have that place dedicated to record what did your applications say and probably you didn't see or don't remember. Just look at /var/log and then check your respective log.

In my case I found the file /var/log/mongodb/mongod.log

Since it had many lines I just checked the last part of the log with the tail command:

sudo tail -n300 /var/log/mongodb/mongod.log

Still with that I got a wall of text so i decided to fed my chatbot to provide some advice. The chatbot showed that the most frequent text was indeed the most important part of this issue.

[ERROR]: __posix_open_file, 924: /var/lib/mongodb/WiredTiger.turtle: handle-open: open: Permission denied"}}

A wild Wire-tiger-turtle-appeared!🔌🐯🐢

The chatbot suggested that /var/lib/mongodb/WiredTiger.turtle should be owned by mongodb. I noted the file was owned by root. I tryed changing the owner to mongodb and it didn't work. Then tried changing the folder to be owned by mongodb. This last attemp was sucesful when i restarted mongod and check with systemctl status mongod.

What I learned from that story

This story is longer than what I wrote. At the start I didn't know where to look and i received suggestions from the chatbot that lead me nowhere. This is the reason why I want to highlight the importance of logs. They provide some important detail that you can use to feed a chatbot, chat with another team member and to understand yourself what is happening. Take this story as a way to keep checking them when issues arise.

Side story

why did that wiredTiger.turtle file became owned by root? Well it happened that when I did the first hot fix I started the db with sudo mongod --config /etc/mongod.conf

With that command I could use mongodb without problems during that session but I got the problem I tried to tweak again the app two days later.

Let's keep coding, dev-san 🤓 頑張って!

PostGres Database Replication Using Pglogical

Ruben Alvarado — Tue, 24 Feb 2026 20:52:44 +0000

Originally published on Hashnode

This is an example of PostgreSQL database replication using the pglogical extension. In this example, I used Docker containers, with each container having its own database. When data is written to the primary database, the secondary container receives the same data.

👨‍💻A man proudly told his wife, “I’m an SQL DB admin!”

She threw him out of the house…

Because he had one to many relationships💔 — SQL News Network

Start Docker

If you have docker engine use

sudo systemctl start docker
sudo systemctl enable docker // if you want start at boot

Or if you have docker desktop use this in debian Linux (installed from .deb package)

systemctl --user start docker-desktop

Create configuration files

You need to create 2 config files as shown in this folder tree

/<PATH_TO_PROJECT>/docker/
│
├── Dockerfile.pglogical
└── postgres/
    └── docker-compose.yml

Define config files

docker-compose.yml is the file that defines how to run the containers.

cd <RATH_TO_PROJECT>/docker/postgres/ 
nano docker-compose.yml

paste this content for your yml

container names are inside the services part. For these example containers are pg1 and pg2

services:
  pg1:
    build:
      context: ..
      dockerfile: Dockerfile.pglogical      
    container_name: pg1
    command:
      - postgres
      - -c
      - shared_preload_libraries=pglogical
      - -c
      - wal_level=logical
      - -c
      - max_replication_slots=10
      - -c
      - max_wal_senders=10
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: testdb
      POSTGRES_HOST_AUTH_METHOD: trust
    ports:
      - "5433:5432"
    volumes:
      - pg1_data:/var/lib/postgresql/data
    networks:
      - pgnet

  pg2:
    build:
      context: ..
      dockerfile: Dockerfile.pglogical
    container_name: pg2
    command:
      - postgres
      - -c
      - shared_preload_libraries=pglogical
      - -c
      - wal_level=logical
      - -c
      - max_replication_slots=10
      - -c
      - max_wal_senders=10
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: testdb
      POSTGRES_HOST_AUTH_METHOD: trust
    ports:
      - "5434:5432"
    volumes:
      - pg2_data:/var/lib/postgresql/data
    networks:
      - pgnet

networks:
  pgnet:
    driver: bridge

volumes:
  pg1_data:
  pg2_data:

docker-compose.yml has a limitation: It doesn’t let you install software inside the system images!

Since pglogical is not included in the images we need to create Dockerfile.pglogical to specify that we want to add pglogical to the image.

FROM postgres:16

RUN apt-get update \
 && apt-get install -y postgresql-18-pglogical \
 && rm -rf /var/lib/apt/lists/*

Start the containers

Use this command to start the containers

cd <ROUTE_TO_DOCKER_YML>
docker compose up -d

Check that containers are running

docker ps

you will get something like this

CONTAINER ID   IMAGE          COMMAND                  CREATED      STATUS         PORTS                                         NAMES
c61ef5d393cc   postgres-pg1   "docker-entrypoint.s..."   3 days ago   Up 4 minutes   0.0.0.0:5433->5432/tcp, [::]:5433->5432/tcp   pg1
b055528784d5   postgres-pg2   "docker-entrypoint.s..."   3 days ago   Up 4 minutes   0.0.0.0:5434->5432/tcp, [::]:5434->5432/tcp   pg2

Where each line is a container you have running

Get pglogical running in each container

Follow this instructions for pg1 and pg2 the examples shown are also for pg1

Install pglogical in each container using the following command

docker exec -it pg1 psql -U postgres -d testdb

Enable the extension in each container

CREATE EXTENSION pglogical;

The use this sql command to check installed extensions in each container

testdb=# \dx

example output when pglogical is installed

                   List of installed extensions
   Name    | Version |   Schema   |          Description           
-----------+---------+------------+--------------------------------
 pglogical | 2.4.6   | pglogical  | PostgreSQL Logical Replication
 plpgsql   | 1.0     | pg_catalog | PL/pgSQL procedural language
(2 rows)

SELECT pglogical.create_node(
    node_name := 'pg1',
    dsn := 'host=pg1 port=5432 dbname=testdb user=postgres password=postgres'
);

Create table in the provider database

On pg1

Connect postgres

SELECT pglogical.create_replication_set(
    'demo_set',
    replicate_insert := true,
    replicate_update := true,
    replicate_delete := true,
    replicate_truncate := true
);

Create demo table & baseline data

On pg1:

CREATE TABLE demo_events (
    id SERIAL PRIMARY KEY,
    message TEXT,
    created_at TIMESTAMP DEFAULT now()
);

INSERT INTO demo_events (message)
SELECT 'baseline row ' || g
FROM generate_series(1,5) g;

Add the table to the replication set:

SELECT pglogical.replication_set_add_table(
    'demo_set',
    'demo_events'
);

Create subscriptor

On pg2:

SELECT pglogical.create_subscription(
    subscription_name := 'sub_pg1',
    provider_dsn := 'host=pg1 port=5432 dbname=testdb user=postgres password=postgres',
    replication_sets := ARRAY['demo_set'],
    synchronize_structure := true,
    synchronize_data := true
);

Wait a few seconds, then verify:

SELECT * FROM demo_events;

You should see the 5 baseline rows on pg2.

Finally if you try to insert data in the table from pg1 (primary db) it will be successful but if you try from pg2 (replica db) you will get a error-only error. which shows that replication is working as expected.

INSERT INTO demo_events (message)
VALUES ('inserted new row');

Enjoy! 🎉 You now have your replicated databases working. Feel the power of synchronized data with no more differing versions! 🔄💪

Docker Desktop and LM Studio installation

Ruben Alvarado — Wed, 18 Feb 2026 20:44:23 +0000

Originally published on Hashnode.

You can self-host LLMs to automate tasks on your system like retrieving information from a website, writing a database, interacting with note apps, etc. To set up a PC for these automations you can install Docker and LM Studio. This document provides step-by-step instructions for installing and configuring these tools.🤓

🐳Install docker desktop in Ubuntu Linux🐧

Docker Desktop provides pre-packaged MCP servers to interact with web tools, databases, and other systems. It integrates seemlesly with LM Studio, which runs and manages your local LLMs.

Before installing and running these tools, it is important to ensure that your system supports hardware virtualization, which is required for efficient container and virtual machine execution.

First check that you have kmv module loaded to linux kernel with this command

lsmod | grep kvm

You should get a response like this that shows that kvm is running

08:14:19
kvm_intel             487424  18
kvm                  1425408  17 kvm_intel
irqbypass              12288  1 kvm

Download latest DEB package. In my case I used this lnk

Docker Desktop DEB package Download Link

Install the package using apt. Replace <route_to_download_folder> with the route where you have your downloads.

 sudo apt-get update
 cd <route_to_download_folder>
 sudo apt-get install ./docker-desktop-amd64.deb

Sucess you now have Docker Desktop!🤵

🎧Install LM Studio

LM Studio lets you run large language models locally on your PC, including models such as LLaMA, Mistral, and DeepSeek. Running models locally ensures full privacy and allows you to work offline.

To install LM Studio, download the application from the official website:

https://lmstudio.ai/

Follow these commands to install app image. Replace <lmstudio_folder> and <download_folder> with the respective routes in your PC.

mkdir <lmstudio_folder>
cd <lmstudio_folder>
mv <download_folder>/LM-Studio-0.3.36-1-x64.AppImage .
sudo chmod +x LM-Studio-0.3.36-1-x64.AppImage
./LM-Studio-0.3.36-1-x64.AppImage -appimage-extract

After extraction is complete, navigate to this folder inside <lmstudio_folder> and set chrome-sandbox to be executed as root from a normal user (no sudo command requiered for execution)

cd squashfs-root
sudo chown root:root chrome-sandbox
sudo chmod 4755 chrome-sandbox

Now enable LM Studio to be found when you press windows (super key) in Ubuntu. Follow these commands to create the desktop file.

cd ~/.local/share/applications/
sudo nano lmstudio.desktop

Paste these lines to the desktop file. Replace <USER_NAME> with your username in your PC

[Desktop Entry]
Name=LM Studio
Type=Application
Exec=/home/<USER_NAME>/lmStudio/squashfs-root/lm-studio
Icon=/home/<USER_NAME>/lmStudio/squashfs-root/lm-studio.png
Terminal=false

Press the super key and type “lm studio”. You can access the application without knowing its exact location now.🤩

References to Explore

Ubuntu | Docker Docs

Learn how to install, launch, and upgrade Docker Desktop on Ubuntu. This quick guide will cover prerequisites, installation methods, and more.

docs.docker.com

Set New Branch in Git

Ruben Alvarado — Wed, 08 Oct 2025 18:35:59 +0000

If you want to add a new feature to an app you have cloned. You can create a new branch for that feature following these git commands.

git switch -c <branch-name> // creates the branch
git add <file-or-folder>     // or use '.' to stage all changes
git commit -m "<commit-message>"
git push --set-upstream origin <branch-name>

You can also simply try git push, in that case you will get a warning that the branch doesn't exist in remote yet and you receive a suggestion using the --set-upstream parameter. Instead of memorizing the last command with the parameter you can copy and paste the command that the terminal suggests.

And that it. Use this snippet to preserve working code in master and your new code in your feature or bug fix branch.

🤓Happy coding😎

🚀 How to Upload Environment Variables to GitLab CI/CD

Ruben Alvarado — Sat, 13 Sep 2025 21:28:24 +0000

Managing secrets and configuration in GitLab pipelines doesn’t have to be messy. Here’s a quick guide to securely upload your environment variables and integrate them into your .gitlab-ci.yml workflow.

In Gitlab goto left side bar, Settings, CI/CD
Go to variables section, click add variable

From right side bar select select visible and deselect protect variable
In Key write the name of the file that will store all the variables
In value enter the key and values of your variables (values are written without ")
Make sure that your yml script adds the env vars file
.gitlab-ci.yml

Autotest:
  stage: test
  image: node:22
  before_script:
    - cat "$ENV_VARS" | tr -d '\r' > .env

You’ve now securely injected environment variables into your GitLab CI/CD pipeline. No more hardcoding secrets or juggling config files—just clean, maintainable automation.