DEV Community: Jessica Doering

Finding bandwidth hogs on Linux

Jessica Doering — Sat, 25 Jul 2026 22:35:51 +0000

When a Linux server starts feeling slow, uploads stall, or network costs climb, top and htop can only tell part of the story. They show CPU and memory use, not which process is moving data.

For that, start with nethogs, then use iftop or ss to confirm what the process is connected to. If you are working in a stripped-down environment, /proc is still there as a fallback.

Install the tools

These packages are available on most Linux distributions:

# Ubuntu or Debian
sudo apt install nethogs iftop -y

# RHEL or Rocky Linux, with EPEL enabled
sudo dnf install nethogs iftop -y

# Arch Linux
sudo pacman -S nethogs iftop -y

net-tools is not needed for any command in this guide. ip and ss are normally provided by the already-installed iproute2 package. On RHEL-family systems, nethogs and iftop may not be enabled in the default repositories, so enable an appropriate repository first.

Start with `nethogs`

nethogs groups current network traffic by process and shows the PID when it can associate traffic with a local socket. It is the fastest way to find the program responsible for a spike.

sudo nethogs <interface>

Replace <interface> with the network interface you want to inspect, such as eth0. Run ip link show if you need to find its name.

Use this first. Once you have the PID or process name, you can investigate the connection behind it.

Check destinations with `iftop`

iftop shows bandwidth by pairs of hosts and their remote IP addresses. It does not identify the owning process, but it answers the next question: which hosts are involved?

sudo iftop -i <interface>

Run iftop beside nethogs when possible. One shows the process; the other shows busy host pairs and the direction of the data flow.

Verify sockets with `ss`

When you need to confirm a process's active TCP connections, use ss. It maps sockets to process names and PIDs.

sudo ss -tnp

-t shows TCP connections.
-n keeps addresses as raw IPs instead of looking up hostnames.
-p includes the process name and PID.

This is useful when nethogs points to a PID and you need to inspect its socket connections or send queue (Send-Q).

Use `/proc` on minimal systems

Containers, rescue shells, and stripped-down VMs may not have the monitoring tools installed. In that case, inspect the process's open file descriptors through /proc:

sudo ls -la /proc/<pid>/fd | grep socket

Entries such as socket:[123456] contain a socket inode number. Look for that inode in /proc/<pid>/net/tcp for IPv4 TCP or /proc/<pid>/net/tcp6 for IPv6 TCP. Use /proc/<pid>/net/udp* for UDP sockets. These paths inspect the target process's network namespace, which matters when it runs in a container.

Quick reference

Tool	What it shows	Use it for
`nethogs`	Bandwidth per program	Finding the process using traffic
`iftop`	Bandwidth by host pair	Identifying hosts and traffic flow
`ss -tnp`	Established TCP sockets	Mapping connections to PIDs
`/proc`	Socket inodes and protocol tables	Diagnosing minimal systems

A practical workflow

Run nethogs and identify the PID using the bandwidth.
Use ss -tnp to see that process's TCP connections; use iftop to identify busy host pairs on the same interface.
Confirm whether the traffic is expected before stopping anything.

Routine jobs such as cron tasks and rsync backups often explain a network spike. A backup that overlaps with another job can look suspicious until you match the PID to the process. Confirm the process identity before killing it.

Gem: A Desktop Scanner That Finds GitHub Repos Before They're Trending

Jessica Doering — Sat, 25 Jul 2026 00:26:56 +0000

Gem is a desktop app for developers tired of GitHub’s trending page only ever showing what’s already popular. Instead of scrolling through the same top-100 lists, you set up “recipes”, basically saved searches combining stars range, language, topic, recency, and excluded keywords, and Gem runs them on a rotation, surfacing recently active repos that haven’t blown up yet, or might just always remain undiscovered otherwise.

Save a repo and its topics score higher next time. Skip one and they score lower. You can also just set the weights manually per topic, language, or keyword if you’d rather tune it by hand than let the app learn from your behavior. Repos flow through a simple triage pipeline too: everything lands in an Inbox, then you sort into Gems, Tools to Try, or Skipped, with a Discovery Guide of prebuilt recipes (AI/ML, self-hosted, mobile, games, etc.) for when you don’t want to write GitHub search syntax from scratch.

It’s built on Tauri v2 with a Rust backend (reqwest for the GitHub API, sqlx for SQLite, tokio running the scan loop) and a React/TypeScript frontend. Everything, including your recipes and scoring weights, is in a local SQLite file. No account, no server, no syncing. If you’ve ever found a great repo by accident and wondered how many more you’ve missed, give it a try and let me know what you think.

https://github.com/pinkpixel-dev/gem

I Built Quota to Track my AI Tools

Jessica Doering — Thu, 16 Jul 2026 04:19:08 +0000

I wanted an easy way to track usage across multiple subscriptions and multiple accounts, so I created Quota.

Quota is a desktop app and VS Code extension that gives you one place to track your AI coding-tool usage across accounts and providers. Connect each service once, then see your remaining usage, pin your most used accounts, switch between layouts, and export account summaries as JSON.

The VS Code extension also adds a status-bar indicator and webview panel. In the settings you can decide which providers appear in the status bar. It’s available on both the VS Code Marketplace and Open VSX, so it can work in compatible editors like Antigravity and Kiro as well.

I wanted to share because it's been really useful for me, especially being able to easily view my usage in my VSCode status bar, and hopefully others find it useful too.

So if you use Copilot, Codex, Claude Code, Cursor, Kiro, Antigravity, or some combination, please give it a try and let me know what you think!

Desktop App

VSCode

Open VSX

I built Stitchlet because my crochet patterns were scattered across a dozen apps and a stack of paper

Jessica Doering — Sat, 11 Jul 2026 06:53:57 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

I built Stitchlet, a private, self-hosted crochet project companion for keeping patterns, photos, materials, notes, and progress tracking together in one place.

I've been crocheting and designing patterns for years, so this project came directly from problems I've run into myself. Crochet projects have a way of scattering across printed patterns, PDF files, handwritten notes, photos, row counters, and random scraps of paper. I wanted one calm, organized place for everything.

With Stitchlet, you can:

Create and organize crochet projects
Upload and view pattern PDFs inside the app
Save project and progress photos
Track rows or rounds with multiple counters
Record yarn, hook size, colors, dimensions, and other materials
Add custom sections for assembly notes, substitutions, or anything else
Search, sort, and filter projects by status
Back up and restore the entire project library

Stitchlet runs on your own computer, NAS, or home server, so your project files and notes stay under your control instead of getting locked into another subscription service.

Demo

Stitchlet is self-hosted, so there's no shared public demo instance to click into. See the video below.

You can also find setup instructions and more project details in the GitHub repository.

Code

pinkpixel-dev / stitchlet

A self-hosted crochet companion for tracking projects, stitch counters, pattern PDFs, and progress photos locally on your own hardware. 🧶

Stitchlet

Stitchlet is a self-hosted crochet project tracker. It keeps your pattern PDFs, progress photos, stitch/row counters, and material notes together in one place, on hardware you control — a mini-PC, a NAS, a home server, or just your own machine. No account, no subscription, no third-party server holding your project library.

I made this because my own crochet projects were scattered across printed patterns, PDFs, photos in random folders, and notes on paper. Stitchlet is basically the tool I wanted for keeping all of that in one spot while I'm actually sitting there with yarn in my hands.

Features

Dashboard with search, status filtering (Active, Paused, Finished, Frogged), sorting by updated date/title/status, and grid or list view
Upload pattern PDFs and view them in an in-app viewer, or download them
Upload a project photo, with a replace/remove option
Multiple row or round counters per project, each with a name…

View on GitHub

Stitchlet is open source, licensed under Apache 2.0.

How I Built It

Stitchlet is a full-stack TypeScript application built as a single package.

The frontend uses:

React
Vite
React Router
Tailwind CSS
CSS variables for light and dark themes

The backend uses:

Hono
Node.js
SQLite
Drizzle ORM
Zod for shared validation and schemas

The React frontend uses a Hono API that manages projects, counters, custom sections, photos, PDFs, and backup operations.

Project data is stored in SQLite, while uploaded PDFs and images are stored in local folders on the host system. Files are served through application routes rather than a public static directory, which keeps them out of directory listings, though access control itself is left to the network layer (see the README for details on running this behind Tailscale or a reverse proxy).

One decision that mattered a lot was keeping storage local. Stitchlet runs through Docker Compose with mounted volumes for the database, uploads, and backups, so you can update or replace the container without losing your crochet library.

There's also a backup and restore system that packages the SQLite database and uploaded media into a ZIP archive. You can export that from the settings page and restore it later if you move the app to another machine.

I also made Stitchlet installable as a PWA, so on a phone or tablet it feels more like a dedicated crochet companion, and it’s handy when you're using the row counters mid-project.

The UI is built around how crochet projects and the things crocheters actually use. The counters have large tap targets, project details stay easy to scan, and the dashboard has search, sorting, status filters, grid and list views, and mobile-friendly layouts.

For deployment, there's a Docker image and a Docker Compose setup. You can run it locally, host it on a NAS, or access it privately through something like Tailscale.

What I Learned

This was a good reminder that a project doesn't need a huge audience to be worth building. It just needs to solve a real problem for someone, even if that someone is just me.

Because I actually crochet, I already knew which details mattered, at least to me: fast counters, easy access to PDFs, project photos, a place to list all of the materials I need, a place to write down random notes, and a way to recover everything if needed.

Building around my own workflow made the technical decisions easier, too... like skipping features that sound impressive on paper but wouldn't actually get used while sitting on the couch with yarn in your hands.

Since crocheting is something I do all the time and I will personally really enjoy using this app, this was a really fun challenge for me, and I'm happy to be able to share it and post my first submission!