Forem: Fedya Serafiev

Automated Secure Hosting with Cloudflare Tunnel & Docker

Fedya Serafiev — Sun, 29 Mar 2026 04:33:45 +0000

📖 This article is a translation of the original post published on ITpraktika.com (Bulgarian).

If you own a server — whether a VPS or a home machine — and want to host websites or monitoring tools, security and configuration can quickly become a headache. This post introduces a single Bash script that handles everything for you: from generating strong passwords to spinning up a fully isolated Docker environment.

🛡️ What Does This Script Do?

This tool is built for people who want a professional-grade setup with minimal effort. It automates:

Cloudflare Tunnel — Connects your server to Cloudflare's network without opening ports 80 or 443 on your router or firewall. Your server stays invisible to bots and scanners.
Uptime Kuma — Installs one of the best open-source monitoring tools for tracking your sites and services.
WordPress support — Optionally spins up to 2 independent WordPress sites, each with its own isolated database.
Maximum security — Generates unique 24-character passwords for every component and sets proper file permissions on all config files.
Healthchecks — Intelligently waits for MariaDB to be fully ready before starting your sites, preventing startup race conditions.

🛠️ How to Use It

The entire setup takes less than a minute. SSH into your Linux server and run these three commands:

1. Download the script:

wget https://gist.fedia.eu/urocibg/8edf74d152594176a1052308054ed36c/raw/HEAD/setup_hosting.sh

2. Make it executable:

chmod +x setup_hosting.sh

3. Run the installer:

./setup_hosting.sh

📋 What Happens Next?

The script will ask you a few questions — whether you want Uptime Kuma, how many WordPress sites you need, and your Cloudflare tunnel token. Once you answer, it generates:

An .env file containing all your passwords.
A docker-compose.yml with optimized settings.
An initialization SQL script for your databases.

Once you've answered all the questions, the script takes care of the rest — including starting all the containers. Your entire infrastructure will be online automatically. 🎉

Note: This script is an ideal solution for developers and sysadmins looking for the right balance between cost, security, and ease of maintenance.

Original article (Bulgarian): https://itpraktika.com/hosting-s-cloudflare-tunnel/

I built my first website in 2004. Here's what I wish someone had told me.

Fedya Serafiev — Sat, 21 Mar 2026 08:45:43 +0000

A honest letter from a grandfather who codes — to everyone who thinks they started too late.

Most of you reading this were probably still figuring out what "the internet" even was. I wasn't young. I wasn't fresh out of university. I wasn't some prodigy who grew up with a keyboard in my hands. I was just a person who was genuinely, deeply curious — and that turned out to be enough.

The site was called fedia design. Pure HTML. A little CSS. No frameworks, no npm, no Stack Overflow (well, barely). If something broke, you stared at it until you understood why. That kind of learning leaves marks. Good ones.

"Talent is just patience that hasn't been named yet."

Nobody tells you this part

I've watched colleagues throw around words they don't fully understand — big architectural terms, trendy acronyms, names dropped like currency. I made a choice early on: I would rather explain something simply and be understood, than sound impressive and leave someone confused. The goal was never to impress. It was to be useful.

Every article I write, every tutorial I put together — I ask myself: would someone reading this for the first time actually get it? If not, I rewrite it. Not because I think I'm a great teacher. Because I remember exactly what it felt like not to understand something, and how isolating that can be.

Write for the person you were when you didn't understand anything yet.

IT is not a young person's game

I was already well into my adult life when I seriously started working in tech. People looked at me sideways sometimes. I looked back, smiled, and kept learning. Today I'm a grandfather. And I still write code. I still get excited when something clicks. I still break things and fix them at odd hours of the night.

If you think you're too old to start — you're not. If you think you're not talented enough — talent is just patience that hasn't been named yet. What you need isn't a gift. What you need is to be genuinely interested, stubborn enough to keep going, and honest enough to ask for help when you're stuck.

What I actually believe

We have a responsibility to each other in this field. The more experienced you get, the more you should simplify — not complicate. Share what you know in plain language. Make it easier for the next person. That's how this whole thing grows.

I'm proud of fedia design. I'm proud of every broken tag, every misaligned div, every CSS hack that somehow worked. That's where it all started. And I'm still here, still building, still learning — just with a few more grey hairs and a lot more perspective.

If you're just starting out: welcome. You're going to be fine.

If you want to follow more of my work or see what I've been building, you can find me at itpraktika.com.

How to Install Paperless-ngx with Docker Compose on Ubuntu

Fedya Serafiev — Sat, 21 Mar 2026 08:02:48 +0000

📄 This article is a translation and adaptation of the original post published in Bulgarian at itpraktika.com.

Introduction

Managing documents in a digital environment can quickly become overwhelming — especially as the number of files (PDFs, DOC files, scanned images) grows. Paperless-ngx is a modern Document Management System (DMS) that offers automatic indexing, OCR (Optical Character Recognition), and a powerful search engine.

In this guide, we'll walk through step by step how to install and configure Paperless-ngx using Docker Compose on Ubuntu, so it runs reliably and stably.

Prerequisites

Before we begin, make sure you have:

Ubuntu server (20.04 or newer)
Docker installed
Docker Compose installed
Terminal access (SSH)

💡 If you don't have Docker installed yet, check the official Docker documentation or a guide for your specific distro.

Step 1: Prepare the Directory Structure

Create the necessary folders for storing data:

mkdir -p /data/paperless/{data,media,export,consume,db}

Here's what each folder is for:

data – metadata
media – the actual document files
export – exported documents
consume – incoming folder for automatic import
db – database files

Step 2: Create the docker-compose.yml File

Create the file:

nano docker-compose.yml

Then paste in the following configuration:

version: "3.8"

services:
  broker:
    image: redis:7
    container_name: paperless-redis
    restart: unless-stopped
    command: redis-server --save "" --appendonly no

  db:
    image: postgres:15
    container_name: paperless-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD: paperless_password_change_me
    volumes:
      - /data/paperless/db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U paperless"]
      interval: 10s
      timeout: 5s
      retries: 5

  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    container_name: paperless
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
      broker:
        condition: service_started
    ports:
      - "8000:8000"
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBHOST: db
      PAPERLESS_DBNAME: paperless
      PAPERLESS_DBUSER: paperless
      PAPERLESS_DBPASS: paperless_password_change_me

      # Uncomment if using a domain:
      # PAPERLESS_URL: https://paperless.yourdomain.com
      # PAPERLESS_CSRF_TRUSTED_ORIGINS: https://paperless.yourdomain.com

      PAPERLESS_SECRET_KEY: "change_me_to_something_long_and_random"
      USERMAP_UID: 1000
      USERMAP_GID: 1000

      PAPERLESS_OCR_LANGUAGE: eng
      PAPERLESS_TIME_ZONE: Europe/London
      PAPERLESS_OCR_LANGUAGES: eng

      PAPERLESS_CONSUMER_POLLING: 60
      PAPERLESS_FILENAME_FORMAT: "{created_year}/{correspondent}/{title}"

    volumes:
      - /data/paperless/data:/usr/src/paperless/data
      - /data/paperless/media:/usr/src/paperless/media
      - /data/paperless/export:/usr/src/paperless/export
      - /data/paperless/consume:/usr/src/paperless/consume

🔐 Important: Change paperless_password_change_me and PAPERLESS_SECRET_KEY to strong, unique values before deploying.

Step 3: Start the Containers

Run:

docker compose up -d

After a few seconds, the system will be accessible at:

http://YOUR_SERVER_IP:8000

Step 4: Create an Admin User

No default user is created automatically. You need to create one manually:

docker exec -it paperless python3 manage.py createsuperuser

You'll be prompted to enter:

Username
Email (optional)
Password

After that, you can log into the web interface.

Step 5: Working with Documents

Uploading Files

You have several options:

Drag & Drop in the browser
The Upload button in the UI
Automatic import via the consume folder:

cp *.pdf /data/paperless/consume/

All files placed in that folder will be processed automatically.

Step 6: ⚠️ Domain Configuration (IMPORTANT)

If you plan to use a domain (e.g., behind Cloudflare or nginx), you must add the following environment variables:

PAPERLESS_URL: https://your-domain.com
PAPERLESS_CSRF_TRUSTED_ORIGINS: https://your-domain.com

⚠️ Important notes:

Do NOT add a trailing slash / at the end of the URL
If you use www, add both versions:

PAPERLESS_CSRF_TRUSTED_ORIGINS: https://your-domain.com,https://www.your-domain.com

Why is this necessary?

Without these settings, you will get a 403 CSRF verification failed error. This is a built-in security mechanism that requires the domain to be explicitly trusted.

Common Issues

1. Can't log in

Make sure you created a superuser (Step 4)
Try clearing your browser cache/cookies

2. OCR not working

Verify that all containers are running: docker compose ps
Check language settings in your environment variables

3. Slow processing

This is normal during the initial indexing phase
OCR is CPU-intensive — be patient on lower-end hardware

Best Practices

Use strong, unique passwords
Set up regular backups:

  rsync -av /data/paperless /backup/

Use the /consume folder to automate document ingestion
Organize documents with tags and correspondents from the start

Conclusion

Once you've completed the setup, you'll quickly appreciate how much easier document management becomes. Paperless-ngx isn't just a file store — it's a tool that genuinely saves time when searching, sorting, and organizing information.

A few long-term recommendations:

Set up automated backups from day one
Use a domain with HTTPS if accessible over the internet
Restrict access if the instance is publicly reachable

Don't be afraid to experiment. Paperless-ngx has a lot of automation and customization options you can tune to your workflow. With the right setup and a small initial investment of time, you'll have a fast, reliable, and user-friendly document management system.

📄 Original article in Bulgarian: Как да инсталираме Paperless-ngx с Docker Compose — itpraktika.com

Docker Compose Secrets: How to Stop Hardcoding Passwords in Your docker-compose.yml

Fedya Serafiev — Thu, 19 Feb 2026 06:49:11 +0000

📝 This is a translated and adapted version of the original article published in Bulgarian at itpraktika.com.

We've all done it. You're spinning up a new project, you need a database, and you write something like this:

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: mysupersecretpassword123

It works. You commit it. You push it to GitHub.

And just like that, your database password is now public. Forever. Even if you delete it later, it lives in the git history.

In this article I'll show you three proper ways to handle secrets in Docker Compose — from simple to production-grade — so you never have to hardcode credentials again.

Why This Is a Real Problem

Before we jump into solutions, let's be clear about what's at stake.

Hardcoded secrets in docker-compose.yml are dangerous because:

Git history never forgets. Even if you remove the password in the next commit, anyone with access to your repo history can find it.
It scales badly. The same file gets used in dev, staging, and production — with the same credentials.
It violates the 12-factor app principle of strict separation between config and code.
It's the #1 source of credential leaks in public repositories. GitHub scans for these patterns automatically and will warn you — but the damage is already done.

Method 1: `.env` Files (Quick Win for Development)

The simplest improvement. Instead of hardcoding values directly, you reference them as variables.

Step 1 — Create a .env file:

# .env
POSTGRES_USER=myapp
POSTGRES_PASSWORD=a-much-safer-password
POSTGRES_DB=production_db

Step 2 — Reference it in docker-compose.yml:

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}

Docker Compose automatically reads .env from the same directory — no extra configuration needed.

Step 3 — The most important part. Add .env to .gitignore:

echo ".env" >> .gitignore

Provide a safe template for your team:

# .env.example  ← commit this one
POSTGRES_USER=
POSTGRES_PASSWORD=
POSTGRES_DB=

✅ Pros: Simple, zero dependencies, works everywhere.
⚠️ Cons: The .env file still lives as plaintext on disk. Fine for development, not ideal for production.

Method 2: Docker Secrets (Production-Ready)

Docker has a built-in secrets management system. Secrets are stored encrypted in memory and are never written to disk or exposed as environment variables.

⚠️ Note: Docker Secrets in this form require Docker Swarm mode to be initialized. If you're running a single-node setup, you can still use it — just run docker swarm init once.

Step 1 — Create the secret:

# From a string
echo "my-super-secret-db-password" | docker secret create db_password -

# Or from a file
docker secret create db_password ./password.txt

Step 2 — Reference it in docker-compose.yml:

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_USER: myapp
      POSTGRES_DB: production_db
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password

secrets:
  db_password:
    external: true

The secret is mounted as a file inside the container at /run/secrets/db_password. Many official Docker images (PostgreSQL, MySQL, MariaDB) support the _FILE suffix specifically for this pattern.

Step 3 — Deploy:

docker stack deploy -c docker-compose.yml myapp

✅ Pros: Secrets are encrypted at rest, never in environment variables, ideal for production.
⚠️ Cons: Requires Swarm mode. Slightly more complex to set up.

Method 3: Secrets as Local Files (Swarm-Free Alternative)

If you don't want to use Swarm mode but still want to keep secrets out of your docker-compose.yml, you can mount secret files directly.

Step 1 — Create a directory for secrets (outside your project if possible):

mkdir -p ./secrets
echo "my-db-password" > ./secrets/db_password.txt
echo "my-redis-password" > ./secrets/redis_password.txt

Step 2 — Add secrets directory to .gitignore:

echo "secrets/" >> .gitignore

Step 3 — Mount as read-only files in docker-compose.yml:

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_USER: myapp
      POSTGRES_DB: production_db
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    volumes:
      - ./secrets/db_password.txt:/run/secrets/db_password:ro

  redis:
    image: redis:7-alpine
    command: sh -c 'redis-server --requirepass "$$(cat /run/secrets/redis_password)"'
    volumes:
      - ./secrets/redis_password.txt:/run/secrets/redis_password:ro

✅ Pros: No Swarm required, works with standard docker compose up, keeps secrets out of YAML.
⚠️ Cons: Secret files still live on disk — make sure the host machine is secure.

Bonus: Validate That You're Not Leaking Secrets

Before every commit, check that no secrets ended up in your YAML:

# Search for common patterns in your compose file
grep -Ei '(password|secret|key|token)\s*[:=]\s*[^\$\{]' docker-compose.yml

If this command returns any output — you have a hardcoded secret. Fix it before committing.

You can also add this as a pre-commit hook:

# .git/hooks/pre-commit
#!/bin/sh
if grep -Ei '(password|secret|key|token)\s*[:=]\s*[^\$\{]' docker-compose.yml; then
  echo "❌ Possible hardcoded secret detected in docker-compose.yml. Aborting commit."
  exit 1
fi

Make it executable:

chmod +x .git/hooks/pre-commit

Which Method Should You Use?

Scenario	Recommended Method
Local development	`.env` file + `.gitignore`
Single-server production	Local secret files (Method 3)
Multi-node / orchestrated production	Docker Secrets (Method 2)
CI/CD pipelines	Environment variables injected by the CI system (GitHub Actions Secrets, GitLab CI Variables, etc.)

Quick Checklist Before You Push

[ ] No plaintext passwords in docker-compose.yml
[ ] .env is in .gitignore
[ ] .env.example exists and is committed (with empty values)
[ ] secrets/ directory is in .gitignore
[ ] Pre-commit hook is in place

Conclusion

Hardcoding passwords in docker-compose.yml is one of those habits that's easy to fall into and hard to undo once your repo is public. The good news is that all three methods above are straightforward to implement — even in an existing project.

Start with .env files today if you haven't already. It takes five minutes and immediately eliminates the most common source of accidental credential leaks.

Your future self (and your security team) will thank you.

Written by Fedya Serafiev — itpraktika.com — practical IT solutions and automation.

Why I Stopped Paying for Software: 6 Open Source Tools That Changed How I Work

Fedya Serafiev — Thu, 19 Feb 2026 05:57:12 +0000

📝 This is a translated and adapted version of the original article published in Bulgarian at itpraktika.com.

As a tech enthusiast, I spent years searching for the perfect toolset. I used to believe that a high price tag guaranteed quality — paying for expensive subscriptions, convinced it was the only way to stay professional.

Over time, I discovered something remarkable: the world of open source software has evolved beyond recognition. Today, these solutions don't just compete with paid alternatives — they often surpass them.

In this article, I'm sharing 6 tools that are at the core of my workflow. They save me hundreds of dollars a year and give me complete freedom.

1. Visual Studio Code (VS Code) — My Digital Home 💻

If I had to pick just one tool, it would be VS Code. Before it, I used paid IDEs — they were bloated and slow. VS Code changed everything.

Why it's indispensable:

Lightweight, fast, and completely free
Supports almost every programming language through extensions
IntelliSense predicts your next step as you write code
Integrated terminal and Git built right into the interface

Why I stopped paying: Paid IDEs offer features I rarely use. With VS Code, I only add what I actually need — which keeps it lightning fast.

2. Docker — Containerization Without the Headaches 🐳

Before Docker, I constantly heard: "But it works on my machine!" That was a nightmare for team collaboration. Docker solved that problem once and for all.

What it does:

Packages your software and its dependencies into a "container" so code runs the same everywhere
Spin up databases and servers in seconds with a single command:

docker-compose up

Test different technologies without "polluting" your operating system

The result: I save hours on environment configuration. Docker is the industry standard — and it's free for my use case.

3. LibreOffice — A Full Office Suite, Zero Fees 📝

For a long time I felt trapped by Microsoft 365 subscriptions. Paying a monthly fee just to write documents seemed unnecessary. LibreOffice was my salvation.

Why it works:

Opens and saves .docx, .xlsx, and .pptx files without issues
Writer and Calc cover 100% of my needs for reports and spreadsheets
Files stay local — not locked in someone else's cloud

Why it's better: LibreOffice is stable, powerful, and doesn't interrupt you with upsell prompts. It's a clean tool built for work.

4. Obsidian — My "Second Brain" 🧠

Knowledge management is critical. I used to use Notion, but the slow loading and constant need for an internet connection frustrated me. Obsidian changed the way I think.

What makes it special:

All notes are stored as Markdown files on your own computer
Link ideas together the way your brain actually works
Graph view gives you a visual map of all your knowledge and projects

Why I chose it: My data is permanent. Even if Obsidian ceases to exist, my notes remain as plain text files I can open anywhere.

5. Brave Browser — Speed and Privacy by Default 🦁

The browser is the most-used tool in any workflow. Chrome is decent, but it consumes too many resources and tracks your activity. Brave is the better version.

Key features:

Built-in ad blocker stops annoying ads automatically
Blocks trackers that try to profile you
Pages load significantly faster without the ad overhead

What I save: I no longer pay for premium services just to browse without ads. Brave gives me a clean experience for free.

6. GIMP — Professional Design Without a Subscription 🎨

Photoshop is the industry standard, but its price is steep for smaller projects. For image editing, I use GIMP.

Capabilities:

Layers, masks, filters — everything you need is here
Hundreds of free plugins that extend its functionality
Works perfectly on Windows, Linux, and macOS

My experience: It took me about a week to get used to the interface. Now I handle everything — from banners to photo retouching — without spending a cent.

Quick Comparison Table

Task	Paid Alternative	My Open Source Pick	Main Benefit
Code editing	WebStorm	VS Code	Speed + extensions
Environments	VMware	Docker	Containerization
Office suite	Microsoft 365	LibreOffice	No subscription
Notes	Notion / Evernote	Obsidian	Privacy + offline
Browser	Chrome / Safari	Brave	No ads
Design	Photoshop	GIMP	Full power

Conclusion: Why Open Source Wins 🏆

Switching to these tools isn't just about saving money. It's about sustainability. Open source software is built by the community, for the community.

It's:

Transparent — you know what it does with your data
Flexible — you can tailor it exactly to your needs
Free — you'll never get an email about a "price increase"

The open source world is ready for you. Are you ready for it?

Originally published in Bulgarian at itpraktika.com by Fedya Serafiev — a platform dedicated to practical IT solutions and automation.

How I Built Software from Scratch with Google Antigravity: My Experience

Fedya Serafiev — Tue, 27 Jan 2026 02:27:34 +0000

To be honest? I was skeptical.

In a world flooded with AI tools that promise miracles but deliver only basic responses, I approached Google Antigravity with reservations. I thought: "Okay, another chatbot. It'll write me two lines of code and then freeze."

Today I want to tell you why I was wrong. And how in just a few minutes I turned an idea into a professional, working product.

The Task: Next-Generation PDF Editor

My idea was simple but technically challenging: I wanted to create a PDF editor that runs entirely in the browser. No file uploads to servers, no risk to personal data, no monthly fees. I wanted speed, security, and modern design.

I asked Antigravity. Instead of the standard "Here's sample code for a button", I got something different. I got a partner.

The Process: More Than Just Coding

Antigravity didn't just generate code. It understood context.

When I asked for a "progress bar", it didn't just add a bar – it connected it with asynchronous processing operations.

When I said "I want it to look beautiful", it created a modern, "glass" interface with a dark theme and smooth animations that looks like a $50 application.

Together we built features that typically take days:

Drag & Drop system for page reordering – intuitive and fast
Image to PDF conversion – with automatic resizing
Smart watermarks – text or logo, embedded directly into the document
Multilingual support – switching between Bulgarian and English with one click

The Moment of Truth

The most impressive part wasn't that the code worked. It was how we handled problems. When one library refused to work (due to an outdated version), Antigravity immediately diagnosed the issue, suggested an alternative, and rewrote the logic without losing momentum.

This isn't just a tool that "executes commands". This is an agent that thinks in perspective. It remembers what we did 5 steps ago, suggests improvements I hadn't thought of, and most importantly – writes code that is structured, clean, and production-ready.

The Result

Today I have a fully functional PDF Editor. It's not just a prototype. This is a tool I use daily. And we made it together – I provided the vision, Antigravity provided the engineering power.

If you're wondering whether the future of programming is here – yes, it's here. And it's called Google Antigravity.

Download the source code from my *GitHub***

Created with ❤️ by Fedya Serafiev, Google Antigravity, and *ITpraktika.com***

Original article in Bulgarian: https://itpraktika.com/google-antigravity-2/

💝 If you found this article useful, consider supporting my work:

💖 Your support means a lot!

Critical Issues with Windows 11 January Update (KB5074109): What You Need to Know

Fedya Serafiev — Sat, 24 Jan 2026 12:11:53 +0000

January 2026 started with challenges for Windows 11 users. Microsoft's latest security update KB5074109, which was supposed to bring stability and security, triggered a wave of technical problems – from system lockups to black screens.

Although the update patches over 100 vulnerabilities, including three critical zero-day exploits, the cost for many users has been high.

📊 By The Numbers

100+ Patched vulnerabilities
3 Critical zero-day exploits fixed
1000+ Problem reports from users and sysadmins

🔴 Main Symptoms and Issues

Reports from users and system administrators point to several major defects in the new version:

1. Complete System Lockups

Many users report sudden computer freezing without the familiar Blue Screen of Death (BSOD). The problem is particularly severe when working with graphics-intensive applications such as 3D modeling software (BforArtists/Blender).

2. Black Screens and Graphics Regressions

Nvidia and AMD graphics card owners are encountering black screens immediately after installation. It appears that changes to the Windows kernel graphics stack conflict with current drivers.

3. Cloud Storage and Outlook Problems

Applications that store data in OneDrive or Dropbox frequently stop responding (hanging). Classic Outlook is also affected – it either won't start or freezes when attempting to access emails.

4. Azure Virtual Desktop Errors

Business users report inability to connect remotely (error 0x80080005).

🔧 Why Is This Happening?

The KB5074109 update for versions 24H2 and 25H2 includes massive changes to DirectX and the servicing stack. These changes aim to optimize the operation of NPUs (neural processors) for AI features in Copilot+ computers, but apparently lead to incompatibility with older drivers and specific File Explorer configurations.

✅ How to Protect Your System? (Working Solutions)

If you've already installed the update and are experiencing problems, experts recommend the following steps:

Step 1: Uninstall the Update

Go to Settings → Windows Update → Update history → Uninstall updates. Find KB5074109 and select "Uninstall". Restart the system immediately.

Step 2: Pause Automatic Updates

After uninstalling, stop automatic updates for 1-2 weeks until Microsoft releases an official fix.

Step 3: Update Graphics Drivers

Check for the latest WHQL drivers from Nvidia or AMD websites. In some cases, however, rolling back to a previous driver version may be the more stable solution.

Step 4: Azure-Specific Fix

Microsoft has already released an emergency patch (KB5077744) specifically for Azure Virtual Desktop issues. If this is your only problem, install only this patch.

📌 Conclusion

The situation puts system administrators in a difficult position: leave systems vulnerable to serious cyber threats or risk workflow stability.

For regular users, the advice is clear: if your computer is running unstably after the latest update, don't hesitate to remove it and wait for a corrected version from Microsoft.

Microsoft is expected to coordinate additional fixes in the coming days. Follow official channels for updates.

💡 Quick Summary

Problem: Windows 11 update KB5074109 causing crashes, black screens, and application hangs

Affected: Versions 24H2 and 25H2

Quick Fix: Uninstall KB5074109 and pause updates temporarily

Alternative: Install KB5077744 if you only have Azure issues

This article is a translation of the original Bulgarian article: Windows 11 update KB5074109: Problems and fix

💝 If you found this article useful, consider supporting my work:

💖 Your support means a lot!

Why Use Ripgrep Over grep in 2026: The Complete Guide

Fedya Serafiev — Fri, 23 Jan 2026 17:44:03 +0000

Introduction 🚀

You've probably watched your terminal freeze while grep searches through, say, 10 GB of log files. Using ripgrep, this took about 5 seconds, while classic grep was still processing the first gigabyte. This isn't a coincidence. This is the difference between a tool from the 1970s and a modern tool built for today's needs.

In this article, I'll explore why ripgrep (command: rg) has become the standard for code searching in 2026. You'll see concrete examples, benchmarks, and practical tips for daily work.

📖 This article is also available in Bulgarian: Защо да използваме Ripgrep, а не grep през 2026 г.

What is Ripgrep? 🔍

Ripgrep is a line-oriented search tool written in Rust. It recursively searches directories for text patterns. By default, it respects .gitignore rules and automatically skips hidden files, binary files, and unnecessary directories.

Key Features:

Speed: Extremely fast, often 10-20x faster than grep
Smart defaults: Respects .gitignore, .ignore, hidden files
Unicode support: Full UTF-8 support without performance loss
Cross-platform: Works on Windows, macOS, and Linux
Parallelization: Automatically uses all CPU cores

Why is Ripgrep Faster Than grep? ⚡

1. Modern Rust Architecture

Ripgrep uses Rust's regex engine, which combines:

Finite automata: Efficient regular expression processing
SIMD instructions: Parallel processing of multiple bytes at once
Aggressive literal optimizations: Searching for literal strings before regex

2. Automatic Parallelization

Unlike grep, ripgrep uses all available CPU cores by default. When searching through thousands of files, this makes a huge difference.

Benchmark Example (Linux kernel source tree):

ripgrep:  ~0.06 seconds
GNU grep: ~0.67 seconds
Difference: 11x slower

3. Intelligent Strategy Selection

Ripgrep automatically chooses the optimal strategy:

Memory maps for single large files
Incremental buffering for multiple files
Automatic binary file detection

4. Optimized Line Counting

Ripgrep counts lines using packed comparisons (16 bytes at a time). This is significantly faster than the naive byte-by-byte approach.

Practical Comparisons: Ripgrep vs grep 📊

Scenario 1: Searching a Large Codebase

Task: Find all uses of a variable in a React project.

# With grep (slow, noisy)
$ time grep -r "useState" . --exclude-dir=node_modules --exclude-dir=.git
real    0m8.342s

# With ripgrep (fast, clean)
$ time rg "useState"
real    0m0.089s

Result: Ripgrep is 93x faster in this real scenario.

Scenario 2: Searching with Line Numbers

# grep
$ time grep -rn "function" .
real    0m9.484s

# ripgrep
$ time rg -n "function"
real    0m1.664s

Result: Ripgrep is 5.7x faster with line numbers enabled.

Scenario 3: Real Monorepo (1.4 GB, 250,000 files)

Tool	Time	Files Scanned
grep	45s	250,000+
ripgrep	2.3s	~15,000

Ripgrep automatically skipped node_modules, .git, dist, build, and others.

Smart Defaults 🎯

Automatic Ignoring

Ripgrep automatically respects:

.gitignore files
.ignore files
.rgignore files
Hidden directories (starting with .)
Binary files

Example:

# grep requires long exclude flags
grep -r "error" . \
  --exclude-dir=node_modules \
  --exclude-dir=.git \
  --exclude-dir=dist \
  --exclude-dir=build \
  --exclude-dir=.venv \
  --exclude-dir=__pycache__

# ripgrep does this automatically
rg "error"

Automatic Case-Insensitive Search

If your query is all lowercase, ripgrep becomes case-insensitive:

# Automatically case-insensitive
$ rg "error"        # finds Error, ERROR, error

# If it has uppercase, becomes case-sensitive
$ rg "Error"        # finds only Error, ERROR

Colored Output by Default

No need to add --color=auto. Ripgrep automatically colors results.

Installing Ripgrep 💻

Ubuntu/Debian

# Ubuntu 18.10+
sudo apt update
sudo apt install ripgrep

# For older versions or latest release
RIPGREP_VERSION=$(curl -s "https://api.github.com/repos/BurntSushi/ripgrep/releases/latest" | grep -Po '"tag_name": "\K[0-9.]+')
wget -qO ripgrep.deb "https://github.com/BurntSushi/ripgrep/releases/latest/download/ripgrep_${RIPGREP_VERSION}-1_amd64.deb"
sudo dpkg -i ripgrep.deb

macOS

# With Homebrew
brew install ripgrep

Windows

# With Chocolatey
choco install ripgrep

# With Scoop
scoop install ripgrep

# With winget
winget install BurntSushi.ripgrep.MSVC

Arch Linux

sudo pacman -S ripgrep

Via Cargo (Rust)

cargo install ripgrep

Verify Installation

rg --version
# ripgrep 15.0.1 (or newer)

Practical Usage Examples 🛠️

1. Basic Search

# Search for "TODO" recursively in current directory
rg "TODO"

# Search for exact word
rg "\bfunction\b"

# Case-sensitive search
rg -s "Error"

2. Search by File Type

# Only Python files
rg "import" -t py

# Only JavaScript/TypeScript
rg "useState" -t js -t ts

# Exclude JavaScript
rg "error" -T js

# See all available types
rg --type-list

3. Show Context

# 2 lines before and after match
rg "error" -C 2

# 3 lines before
rg "error" -B 3

# 3 lines after
rg "error" -A 3

4. Search Specific Files

# Search only in .env files
rg "API_KEY" -g "*.env"

# Search in all config files
rg "database" -g "*config*"

# Exclude test files
rg "function" -g "!*test*"

5. Text Replacement (with other tools)

# Find all matches and replace with sed
rg "oldName" -l | xargs sed -i 's/oldName/newName/g'

# Or with modern ripgrep + sd (string-displacing tool)
rg "oldName" -l | xargs sd "oldName" "newName"

6. Search Compressed Files

# Search in .gz, .xz, .bz2, .lz4 files
rg "error" -z
# or
rg "error" --search-zip

7. Show Only File Names

# Show only files containing pattern
rg "TODO" -l

# Show only files NOT containing pattern
rg "TODO" --files-without-match

8. Match Statistics

# Count matches
rg "error" -c

# Show statistics
rg "error" --stats

Advanced Techniques 🎓

1. Combining with Other Tools

# Ripgrep + fzf for interactive search
rg --line-number --no-heading "." | fzf

# Ripgrep + bat for syntax highlighting
rg "function" -l | xargs bat

# Ripgrep + jq for JSON files
rg "userId" --json | jq '.data.text'

2. Using a Config File

Create ~/.ripgreprc:

# Always show line numbers
--line-number

# Always show hidden files
--hidden

# Ignore specific directories
--glob=!.git/
--glob=!node_modules/
--glob=!dist/

Activate it:

export RIPGREP_CONFIG_PATH="$HOME/.ripgreprc"

3. Regex Patterns

# Email addresses
rg "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"

# IP addresses
rg "\b(?:\d{1,3}\.){3}\d{1,3}\b"

# URLs
rg "https?://[^\s]+"

# Hex colors
rg "#[0-9A-Fa-f]{6}\b"

4. Multiline Search

# Search multi-line patterns
rg -U "function.*\{.*\}" -A 5

# PCRE2 regex for complex patterns
rg -P "(?s)function.*?end"

When to Use grep Instead of Ripgrep? 🤔

There are situations where grep is the better choice:

1. Maximum Portability

Grep is everywhere. If you're writing scripts for multiple systems, grep is safer.

2. POSIX Compliance

Ripgrep is not POSIX-compliant. If you need POSIX compliance, use grep.

3. Piping from stdin

For streaming data and pipe processing, grep is sometimes more suitable:

# grep is good here
ps aux | grep python

# ripgrep works but isn't optimal
ps aux | rg python

4. Minimal Embedded Systems

On systems without the ability to install additional software, grep is the only option.

5. Specific Legacy Scripts

If you have old scripts that rely on grep's exact behavior, migration might create problems.

Ripgrep in CI/CD and Automation 🤖

GitHub Actions

name: Code Quality
on: [push, pull_request]

jobs:
  check-todos:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Install ripgrep
        run: |
          wget https://github.com/BurntSushi/ripgrep/releases/download/14.1.0/ripgrep_14.1.0-1_amd64.deb
          sudo dpkg -i ripgrep_14.1.0-1_amd64.deb

      - name: Check for TODOs
        run: |
          if rg "TODO|FIXME" -t py; then
            echo "Found TODOs in code!"
            exit 1
          fi

Docker

FROM ubuntu:22.04

# Install ripgrep
RUN apt-get update && \
    apt-get install -y ripgrep && \
    rm -rf /var/lib/apt/lists/*

# Use in scripts
COPY search.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/search.sh

Pre-commit Hooks

#!/bin/bash
# .git/hooks/pre-commit

# Check for debug statements
if rg "console.log|debugger" -t js -t ts --quiet; then
    echo "❌ Found debug statements in code!"
    rg "console.log|debugger" -t js -t ts
    exit 1
fi

echo "✅ No debug statements found"

Performance: Real Numbers 📈

Test 1: Monorepo (250,000 files, 1.4 GB)

Operation	grep	ripgrep	Improvement
Search "error"	45.2s	2.3s	19.6x
Regex search	67.8s	3.1s	21.9x
Search with -n	72.4s	3.8s	19.0x

Test 2: Single Large File (10 GB log)

Operation	grep	ripgrep	Improvement
Search "ERROR"	18.2s	4.8s	3.8x
Regex pattern	45.6s	12.3s	3.7x

Test 3: Python Codebase (5,000+ files)

# Search import statements
$ time grep -rn "^import " --include="*.py" .
real    0m3.421s

$ time rg "^import " -t py
real    0m0.156s

Result: 21.9x faster for daily tasks.

Common Mistakes and Solutions ❌✅

Mistake 1: Ripgrep Doesn't Find Files

Problem: rg "text" shows no results, but you know the text exists.

Solution: Files might be ignored.

# Show all files, including ignored ones
rg "text" -u

# Show even hidden and binary
rg "text" -uuu

# Check which files are ignored
rg --files | wc -l
rg --files -u | wc -l

Mistake 2: Slow Search in Home Directory

Problem: rg "something" in /home or / is very slow.

Solution: Limit the scope.

# Search only in specific directory
rg "something" ~/projects/

# Or add --max-depth
rg "something" --max-depth 3

Mistake 3: Regex Doesn't Work as Expected

Problem: Regex from grep doesn't work in ripgrep.

Solution: Use PCRE2 mode.

# Standard regex (might not work)
rg "(?<=@)\w+"

# With PCRE2 support
rg -P "(?<=@)\w+"

Mistake 4: Can't Search UTF-16 Files

Solution: Ripgrep doesn't support UTF-16. Convert first:

iconv -f UTF-16 -t UTF-8 file.txt | rg "pattern"

Conclusion: Why Ripgrep is the Future 🌟

After thoroughly examining ripgrep, here's why it's the right choice in 2026:

Key Advantages:

✅ Speed: 10-20x faster than grep in real scenarios

✅ Intelligence: Automatic ignoring of unnecessary files

✅ Modernity: Built for today's codebases

✅ Safety: Written in Rust, memory-safe

✅ Convenience: Better defaults, fewer flags

✅ Unicode: Full support without performance penalty

✅ Parallelization: Automatically uses all cores

When to Start Using Ripgrep:

✅ You work with large codebases
✅ You search frequently across multiple files
✅ You use git and have .gitignore
✅ You value your time and productivity
✅ You work with Unicode text
✅ You have a multi-core processor

When to Stick with grep:

⚠️ You write POSIX-compliant scripts
⚠️ You work on embedded systems without Rust
⚠️ You have legacy systems without update capability
⚠️ You process stdin pipes intensively

Additional Resources 📚

Official Documentation

Useful Tools

bat: Syntax highlighting cat (works perfectly with rg)
fd: Modern find (ripgrep's sibling)
fzf: Fuzzy finder (combines great with rg)
sd: Modern sed (for text replacement)

Community

Quick Copy Commands 📋

# Installation
brew install ripgrep                    # macOS
sudo apt install ripgrep                # Ubuntu/Debian
cargo install ripgrep                   # Rust

# Basic commands
rg "pattern"                            # Basic search
rg "pattern" -t py                      # Python only
rg "pattern" -C 2                       # With context
rg "pattern" -l                         # File names only
rg "pattern" -uuu                       # Search everywhere

# Advanced
rg "pattern" -g "*.{js,ts}"            # Specific extensions
rg "pattern" --stats                    # Show statistics
rg -P "complex.*regex"                  # PCRE2 regex
rg "pattern" -z                         # In compressed files

# Configuration
export RIPGREP_CONFIG_PATH="$HOME/.ripgreprc"

Final Thoughts 💭

Switching from grep to ripgrep isn't just changing a tool. It's modernizing your workflow. In the world of 2026, where codebases grow exponentially and time is precious, ripgrep is the natural choice.

Start today. Install it. Use it for a week. You won't go back.

Good luck! 🚀

Article is current as of January 2026. Ripgrep continues to be actively developed.

💝 If you found this article useful, consider supporting my work:

💖 Your support means a lot!

Docker & Docker Compose: From Zero to Server (A Practical Guide)

Fedya Serafiev — Thu, 22 Jan 2026 12:40:45 +0000

Welcome to the world of modern technology! If you're a beginner in programming or system administration, you've probably heard the word Docker constantly. It might sound complicated, but the truth is that Docker was created to make our lives easier, not harder.

In this first part of our series, we'll journey from "What is this?" to launching an entire infrastructure with Docker Compose. And we'll do it the professional way – directly on a server.

This article is a translation of the original Bulgarian article: Docker & Docker Compose: от нулата до сървър

1. The Problem: "It Works on My Machine!" 😫

Imagine you've written an amazing program. It works perfectly on your laptop. You send it to a client or upload it to a server and... boom! Nothing works. It turns out the server has a different version of Python, a library is missing, or the database settings are different.

This is called an "environment conflict." Before Docker, programmers wasted hours (and days) configuring servers.

The Solution: The Digital Container 📦

Docker takes your program and encloses it in a "container." Inside this container is everything needed:

The code itself
The libraries it uses
System settings

When you give this container to someone else, it works in exactly the same way because the operating system on the computer no longer matters. Docker provides isolation.

2. Preparation: Where Will We Work? 🌐

To learn Docker properly, you need to use it where it belongs – on a Linux server.

Many tutorials start with Windows installation (Docker Desktop), but this often confuses beginners with additional BIOS settings, virtual machines, and unnecessary RAM consumption. That's why we'll take the professional approach.

Step 1: Server Access

If you have your own server (VPS) with Ubuntu, great! If you don't, you can rent one for a few euros per month from providers like DigitalOcean, Hetzner, or local ones.

Connect to your server via terminal (PowerShell on Windows or Terminal on Mac):

ssh root@your-ip-address

3. Professional Installation (All at Once) 🛠️

Forget long guides. Docker provides an official script that does everything for you. Once you've logged into the server, simply copy and paste this:

curl -fsSL https://get.docker.com -o install-docker.sh
sudo sh install-docker.sh

What just happened?

You downloaded the installation script
You executed it with administrator privileges
Docker is now installed and ready to work

To check if everything is okay, type:

docker --version

If you see a version (e.g., Docker version 24.x.x), you're ready for the magic! ✨

4. The Three Pillars of Docker: Image, Container, Registry 🏗️

Before we start something, you need to understand three basic concepts:

Image: This is a "frozen" snapshot of your program. It doesn't do anything, just sits on disk. Think of it as a cake recipe.
Container: This is the actual cake. When you "start" the image, it becomes a live, working process (container). You can create 100 containers from the same image.
Registry: The place where images are stored. The biggest is Docker Hub – it has ready-made images for everything: databases, web servers, programming languages.

5. Your First Container: Web Server in 5 Seconds 🚀

Let's run Nginx – the most widely used web server in the world. On a regular server, its installation takes time and configuration. With Docker, it's one command:

docker run -d -p 80:80 --name my-site nginx

Command Breakdown (Important!):

docker run: Tells Docker to find the image and start it
-d: (Detached) Means "run in the background." Without it, your terminal will be blocked by server logs
-p 80:80: This is critical! The first 80 is your server's port. The second 80 is the port inside the container. We're saying: "When someone visits my IP, forward them to the container"
--name my-site: We give it a name so we can recognize it
nginx: The name of the image we're pulling from Docker Hub

Result: Open your browser and type your server's IP address. You should see: "Welcome to nginx!". Congratulations, you're a system administrator! 😎

6. How to Manage the Chaos? (Survival Commands) 🕹️

Now that something is running, we need to know how to control it.

See which containers are currently running:

  docker ps

See all containers (even stopped ones):

  docker ps -a

Stop the server:

  docker stop my-site

See what's happening "inside" (Logs):

  docker logs my-site

(If something doesn't work, this is where you'll see why)

7. The Grand Finale: Docker Compose 🎼

One container is easy. But what do we do if we need a website (Nginx) + database (MySQL)? Writing two long docker run commands and manually connecting them is torture.

This is where Docker Compose comes in. It allows you to describe your entire infrastructure in one file.

Step 1: Installation

On modern systems, it comes with Docker, but check with:

docker compose version

Step 2: Creating the Project

Create a folder for your project and enter it:

mkdir my-app && cd my-app

Now create a file named docker-compose.yml. You can use the nano editor:

nano docker-compose.yml

Put this code inside:

version: '3.8'

services:
  web:
    image: nginx
    ports:
      - "8080:80"

  database:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: your-password-here

(Press Ctrl+O, Enter, then Ctrl+X to save and exit nano)

Step 3: The Magic Begins

Instead of starting things one by one, just write this:

docker compose up -d

What happened? Docker Compose read the file, understood you need two containers, created a virtual network between them, and started them simultaneously. Now you have a working web server on port 8080 and a database underneath it.

To stop and delete everything at once:

docker compose down

8. Why Did This Work "Right Away"? 💎

If you followed the steps, you probably already have a working system. Here are the secrets to success:

Clean server: When we work on clean Linux, there are no conflicts with Windows settings
YAML syntax: Be careful with indentation in docker-compose.yml – it matters! Don't use Tab, only spaces
Ports: If port 80 is occupied, you can always change it to 8081 or 8082

Conclusion and Next Steps

Today you learned the basics of the most important technology for cloud services. You now know how to:

Install Docker professionally
Start ready-made programs (Images) as containers
Orchestrate complex systems with Docker Compose

In the next article, we'll move to the next level: How to package our own software. We'll write our first Dockerfile and turn simple code into a professional Docker image.

About the Author:
Fedya Serafiev is the creator of ITpraktika.com – a platform dedicated to practical IT solutions and automation. With extensive experience in system optimization and web technologies, he transforms complex technical cases into clear and easy-to-follow steps.

Original Article (Bulgarian): Docker & Docker Compose: от нулата до сървър

Related Links:

💝 If you found this article useful, consider supporting my work:

💖 Your support means a lot!

Best VPS Servers in 2026: A Comprehensive Guide

Fedya Serafiev — Thu, 22 Jan 2026 02:44:55 +0000

In the digital world of 2026, speed and security are no longer luxuries—they're essential for survival. If shared hosting feels too restrictive and renting an entire physical server is too expensive, the solution is clear: VPS (Virtual Private Server). 🚀

This comprehensive guide explores the leading market players, how technologies have evolved in recent years, and how to make the right choice for your business or personal project.

Original article (Bulgarian): Най-добрите VPS сървъри за 2026

Why VPS Still Matters in 2026 🌐

Despite the rise of serverless technologies and complex cloud ecosystems, VPS remains the "golden middle" for developers and entrepreneurs. Here's why:

Full Control (Root Access): You have the freedom to configure your operating system and install specific software without restrictions.
Isolated Resources: Your RAM and CPU power (vCPU) belong to you alone. Issues on someone else's site on the same server won't affect your performance.
Economic Efficiency: In 2026, prices for NVMe drives and powerful processors have dropped dramatically, making VPS accessible to every startup.
Security and Compliance: Easily implement Zero Trust architectures and meet strict GDPR requirements.

Evaluation Criteria: What to Look for in 2026 📊

Before choosing a provider, pay attention to these key indicators—the quality standard for the current year:

⚡ Hardware Performance

NVMe Gen5 Storage: Forget standard SSDs. Look for providers offering NVMe for lightning-fast read and write speeds.
Next-Gen Processors: Seek systems with AMD EPYC™ 9004 (Genoa) or Intel® Xeon® Scalable (Sapphire Rapids).
DDR5 RAM: Provides significantly higher bandwidth compared to older standards.

🛡️ Security and Reliability

AI-based DDoS Protection: Built-in protection that learns and responds to new threats in real-time.
Automatic Backups: One-click daily backup capability.
99.99% Uptime: Time is money—don't compromise on availability.

📈 Flexibility

Scalability: Ability to add RAM or CPU cores without server restart (hot-plugging).
Location Choice: The server should be close to your users (Europe, USA, or Asia).

Top VPS Providers for 2026 🏆

Based on performance tests, network stability, and price-to-quality ratio, here are the favorites:

Provider	Best For	Key Advantage
Hetzner	Advanced users	Best price-to-performance ratio in Europe 🇪🇺
Hostinger	Beginners and small business	Intuitive interface and excellent support 👨‍💻
DigitalOcean	Developers and SaaS	Extensive tutorial library and easy API 🤖
Ionos	Enterprise clients	Flexible plans and Windows/Linux options 🏢
Kamatera	Maximum scalability	Hourly billing and custom configuration ⏱️

Detailed Review of Top 3:

1. Hetzner – The King of Efficiency

Hetzner continues to dominate the European market. Their Cloud VPS plans offer incredible power at exceptionally low prices, ideal for resource-intensive projects on limited budgets.

Advantage: Own data centers in Germany and Finland.
Disadvantage: Stricter verification process for new profiles.

2. Hostinger – Convenience and Accessibility

If you don't want to spend hours in the terminal, Hostinger is your choice. They offer a powerful control panel and pre-installed templates (WordPress, Docker, Game Servers).

Advantage: Included weekly backups and 24/7 chat support.
Disadvantage: Renewal prices may be higher than initial rates.

3. DigitalOcean – A Coder's Paradise

Known for their "Droplets," DigitalOcean makes application deployment child's play. In 2026, their Marketplace app ecosystem is the richest in the industry.

Advantage: Easy integration with Managed Databases and Kubernetes.

How to Choose the Right Plan? 🤔

The choice depends entirely on your project. Here are some practical examples:

Small blog or portfolio: 1 vCPU, 2GB RAM, 20GB NVMe. Sufficient for fast loading.
Online store (WooCommerce): Minimum 2 vCPU, 4-8GB RAM. Important to have enough memory for processing orders during promotions.
Application testing (Dev Environment): 1 vCPU, 1GB RAM. Focus here is on low cost and ability to quickly delete and recreate the server.
Gaming server (Minecraft/Rust): Minimum 4GB RAM and high-class processor with high clock speed.

Pro tip: Always start with a smaller plan. Most providers allow one-click upgrades, but downgrades are often more complex or impossible without reinstallation.

Trends Driving 2026 🔮

The hosting world never stands still. Here's what we're seeing today:

AI Integration in Management: Servers now predict traffic peaks and suggest optimizations automatically.
Green Hosting (Sustainability): Users prefer providers whose data centers are powered 100% by renewable sources. 🍃
Edge Computing: Using VPS for data processing in close proximity to users (e.g., for IoT devices).
ARM-based Servers: ARM processors (like Ampere Altra) are becoming mainstream in the VPS segment, offering the same power at lower energy consumption and lower cost.

Managed vs. Unmanaged VPS 🛠️

This is the most important question for your maintenance:

Unmanaged: You're the administrator. You install the OS, security patches, and web server. Suitable for system administrators. Lowest price.
Managed: The provider handles the technical aspects. You focus on your business. Ideal for store owners and agencies.

Conclusion 🏁

In 2026, choosing a VPS server is an investment in the stability and growth of your business. Whether you opt for the raw power of Hetzner, the flexibility of DigitalOcean, or the convenience of Hostinger, what matters is choosing a partner that can grow with you.

Always look for NVMe disk availability, check where data centers are located, and don't forget to test support speed before making a long-term commitment.

This article was originally published in Bulgarian on ITpraktika.com.

Author: Fedya Serafiev

Website: ITpraktika.com – Practical IT solutions and automation

💝 If you found this article useful, consider supporting my work:

💖 Your support means a lot!

YAML Validator - Quick Syntax Checker Tool

Fedya Serafiev — Mon, 19 Jan 2026 03:29:15 +0000

Recently, our team has been working more extensively with YAML files, and I noticed we were spending considerable time debugging syntax errors - especially those tricky indentation issues. Anyone who has worked with YAML knows how frustrating it can be to discover that your entire configuration doesn't work because of one extra space or a tab instead of spaces.

I decided to create a simple yet effective YAML validator to help us catch errors instantly, without waiting for a deployment to fail or the CI/CD pipeline to tell us something's wrong.

What Does This Tool Do?

The YAML validator is a web-based tool that checks the syntax of your YAML files in real-time. Simply copy your code or upload a file, and you'll immediately see if there are any issues. If everything is correct, the tool also displays the parsed structure in JSON format, which is very convenient for visualizing the data.

Why Is It Useful?

YAML (YAML Ain't Markup Language) is used everywhere in modern development:

Kubernetes manifests and configurations
Docker Compose files
CI/CD pipeline configurations (GitHub Actions, GitLab CI, etc.)
Ansible playbooks
Configuration files for various applications

A small indentation error can lead to hours of debugging, especially in complex configurations. This tool saves you exactly that time.

Key Features

I made it as practical and user-friendly as possible:

Real-time validation - write and immediately see the results
File upload - you can check your .yaml/.yml files directly
Detailed error messages - exactly where the problem is and what's wrong
Bilingual interface - Bulgarian and English
Copy results - easy sharing or saving
Modern and intuitive design - pleasant to work with

How to Use It?

Using it is extremely simple:

Open the tool in your browser
Copy your YAML code or upload a file
The tool automatically validates as you type
If there's an error - you see a detailed description
If everything is OK - you see the parsed structure

Download

The tool is completely free and you can download and use it locally. It's a single HTML file that works directly in the browser - no server or additional installations required.

You can download it from the original article

Or simply open it directly in the browser and save it via "Save As" for local use.

Why a Local Tool?

I preferred to create this as a standalone HTML file instead of an online service for several reasons:

Privacy - your configuration files aren't sent anywhere
Speed - everything works locally, no internet needed
Reliability - you don't depend on external server availability
Easy integration - you can add it to your team's tools

Conclusion

If you work with YAML regularly, this tool can significantly make your life easier. Instead of waiting for errors from various systems, you can check the syntax in advance and save quite a bit of time and nerves.

Happy usage and fewer YAML errors! 🚀

P.S. If you have suggestions for improvements or encounter a problem, don't hesitate to share - all feedback is welcome!

About YAML

YAML is a human-readable data serialization language that's commonly used for configuration files and data exchange between languages. Its clean syntax and support for complex data structures make it ideal for:

DevOps workflows - Infrastructure as Code (IaC)
Container orchestration - Kubernetes, Docker Swarm
Automation - CI/CD pipelines, configuration management
Application configuration - Settings, environment variables

The most common issues in YAML files are:

Indentation errors - Mixing tabs and spaces
Missing colons - After keys
Incorrect nesting - Wrong hierarchy levels
Special characters - Not properly escaped
Syntax issues - Invalid YAML constructs

This validator helps catch all these issues before they cause problems in production!

💝 If you found this article useful, consider supporting my work:

💖 Your support means a lot!

FileCloud: A Modern and Lightweight File Manager

Fedya Serafiev — Sat, 17 Jan 2026 08:14:00 +0000

🌟 Overview

FileCloud is a reliable web-based file management solution designed for personal servers. It offers a premium, app-like experience with a focus on aesthetics, speed, and usability. It provides modern features like drag-and-drop upload, code editing, and full internationalization (EN/BG).

✨ Key Features

📂 File Management: Create folders, delete items, and download files with ease.
✏️ Rename and Organize: Fix typos or restructure your files with a custom, elegant rename modal.
🎨 Folder Customization: [NEW] Mark important folders by changing their color directly from the UI. Your choice is saved permanently!
🌍 Internationalization (i18n): Fully translated interface in English and Bulgarian (български). Switch instantly.
🚀 Drag and Drop: Upload files by simply dragging them into the window.
📝 Built-in Editor: Edit text, code (.js, .css, .py, etc.) and configuration files directly in the browser.
👁️ Media Preview: View images instantly without downloading them.
💎 Premium UI: Dark mode by default, smooth animations, glassmorphism effects, and rich file icons.

🛠️ Installation and Setup

Prerequisites

Node.js (version 14 or newer)
npm

Installation

Clone the repository:

# Clone the repository
git clone [email protected]:fantomas4o/filecloud.git

# Navigate to the project folder
cd filecloud

Install dependencies:

npm install

Start the server:

npm start

Access the application at http://localhost:3000 or http://ip:3000

Server Deployment (Ubuntu/Systemd)

To run FileCloud as a background service:

Copy the project to /opt/filecloud.
Create a systemd service file at /etc/systemd/system/filecloud.service:

[Unit]
Description=FileCloud Service
After=network.target

[Service]
ExecStart=/usr/bin/node /opt/filecloud/server.js
WorkingDirectory=/opt/filecloud
Restart=always
User=root
Environment=NODE_ENV=production

[Install]
WantedBy=multi-user.target

Enable and start the service:

sudo systemctl enable filecloud
sudo systemctl start filecloud

💻 Technologies

Backend: Node.js, Express.js, Multer, FS-Extra
Frontend: HTML5, CSS3 (Custom Properties, Flexbox/Grid), Vanilla JavaScript (ES6+)
Icons: Google Material Icons
Fonts: Google Fonts (One Sans)

🚀 Features in Detail

File Operations

Upload: Drag files directly into the browser or use the upload button
Download: Click on any file to download it instantly
Delete: Remove files and folders with confirmation dialogs
Rename: Change file and folder names with a sleek modal interface

Code Editor

The built-in editor supports syntax highlighting for:

JavaScript (.js)
CSS (.css)
Python (.py)
JSON (.json)
Text files (.txt)
And many more...

Folder Customization

NEW Feature: You can now customize folder colors to organize your workspace visually. The color selection is persistent and saved in your browser.

Internationalization

FileCloud supports multiple languages out of the box:

English (EN): Default interface language
Bulgarian (BG): Fully translated Bulgarian interface

Switch languages instantly from the settings menu.

📦 Project Structure

filecloud/
├── public/
│   ├── css/           # Stylesheets
│   ├── js/            # Client-side JavaScript
│   └── uploads/       # User uploaded files
├── views/
│   └── index.html     # Main application page
├── server.js          # Express server
├── package.json       # Dependencies
└── README.md          # Documentation

🔒 Security Considerations

FileCloud is designed for personal use on private servers. If you plan to expose it to the internet, consider:

Implementing authentication
Adding SSL/TLS encryption
Setting up proper firewall rules
Restricting file upload types and sizes

🤝 Contributing

Contributions are welcome! Feel free to:

Report bugs
Suggest new features
Submit pull requests

GitHub Repository: https://github.com/fantomas4o/filecloud

📝 License

This project is open source and available for free use.

Original article in Bulgarian: FileCloud: Модерен и лек файлов мениджър

About the Author

Fedya Serafiev is the creator of ITpraktika.com – a platform dedicated to practical IT solutions and automation. With extensive experience in system optimization and web technologies, he transforms complex technical cases into clear and easy-to-follow steps. His goal is to help users build more efficient and secure digital projects through real experience and proven tools.

💝 If you found this article useful, consider supporting my work:

💖 Your support means a lot!

Forem: Fedya Serafiev

Automated Secure Hosting with Cloudflare Tunnel & Docker

🛡️ What Does This Script Do?

🛠️ How to Use It

📋 What Happens Next?

I built my first website in 2004. Here's what I wish someone had told me.

A honest letter from a grandfather who codes — to everyone who thinks they started too late.

Nobody tells you this part

IT is not a young person's game

What I actually believe

How to Install Paperless-ngx with Docker Compose on Ubuntu

Introduction

Prerequisites

Step 1: Prepare the Directory Structure

Step 2: Create the docker-compose.yml File

Step 3: Start the Containers

Step 4: Create an Admin User

Step 5: Working with Documents

Uploading Files

Step 6: ⚠️ Domain Configuration (IMPORTANT)

Why is this necessary?

Common Issues

1. Can't log in

2. OCR not working

3. Slow processing

Best Practices

Conclusion

Docker Compose Secrets: How to Stop Hardcoding Passwords in Your docker-compose.yml

Why This Is a Real Problem

Method 1: .env Files (Quick Win for Development)

Method 2: Docker Secrets (Production-Ready)

Method 3: Secrets as Local Files (Swarm-Free Alternative)

Bonus: Validate That You're Not Leaking Secrets

Which Method Should You Use?

Quick Checklist Before You Push

Conclusion

Why I Stopped Paying for Software: 6 Open Source Tools That Changed How I Work

1. Visual Studio Code (VS Code) — My Digital Home 💻

2. Docker — Containerization Without the Headaches 🐳

3. LibreOffice — A Full Office Suite, Zero Fees 📝

4. Obsidian — My "Second Brain" 🧠

5. Brave Browser — Speed and Privacy by Default 🦁

6. GIMP — Professional Design Without a Subscription 🎨

Quick Comparison Table

Conclusion: Why Open Source Wins 🏆

How I Built Software from Scratch with Google Antigravity: My Experience

The Task: Next-Generation PDF Editor

The Process: More Than Just Coding

The Moment of Truth

The Result

Critical Issues with Windows 11 January Update (KB5074109): What You Need to Know

📊 By The Numbers

🔴 Main Symptoms and Issues

1. Complete System Lockups

2. Black Screens and Graphics Regressions

3. Cloud Storage and Outlook Problems

4. Azure Virtual Desktop Errors

🔧 Why Is This Happening?

✅ How to Protect Your System? (Working Solutions)

Step 1: Uninstall the Update

Step 2: Pause Automatic Updates

Step 3: Update Graphics Drivers

Step 4: Azure-Specific Fix

📌 Conclusion

💡 Quick Summary

Why Use Ripgrep Over grep in 2026: The Complete Guide

Introduction 🚀

What is Ripgrep? 🔍

Key Features:

Why is Ripgrep Faster Than grep? ⚡

1. Modern Rust Architecture

2. Automatic Parallelization

3. Intelligent Strategy Selection

4. Optimized Line Counting

Practical Comparisons: Ripgrep vs grep 📊

Scenario 1: Searching a Large Codebase

Scenario 2: Searching with Line Numbers

Scenario 3: Real Monorepo (1.4 GB, 250,000 files)

Smart Defaults 🎯

Automatic Ignoring

Method 1: `.env` Files (Quick Win for Development)