DEV Community: mamoor123

10 Docker commands that actually matter in 2026 🐳

mamoor123 — Sat, 18 Apr 2026 21:37:18 +0000

🐳 You're probably using Docker wrong

Not trying to be mean. But every week I see developers run docker run with 12 flags they copied from Stack Overflow without understanding a single one.

Docker isn't hard. It's just badly taught.

Most tutorials explain it like a college textbook. That's the problem. Let me explain it like a human.

🎯 1) `docker system prune` — Clean up ALL the junk

Your Docker is eating 40GB of disk space and you don't know why.

Here's why: every build, every container, every image you ever pulled — they're all still there. Docker hoards everything.

# Nuclear option — removes EVERYTHING unused
docker system prune -a

# You'll see:
# Deleted Containers: 23
# Deleted Images: 47
# Deleted build cache: 12.4GB
# Total reclaimed space: 31.2GB

🧠 What's actually getting deleted?

Stopped containers
Dangling images (no tag, not used by any container)
Unused networks
Build cache
With -a: ALL unused images (not just dangling ones)

Pro tip — be more surgical:

# Only remove stopped containers
docker container prune

# Only remove unused images
docker image prune -a

# Only remove build cache
docker builder prune

# Only remove unused volumes (⚠️ careful — this deletes data)
docker volume prune

Use it when: your disk is full, you've been building for weeks, you want a fresh start without reinstalling Docker.

⚡ 2) `docker exec -it` — Jump inside a running container

When something breaks IN a container, you need to get inside it.

# Get a shell inside a running container
docker exec -it my-app /bin/bash

# If bash isn't available (Alpine images), use sh
docker exec -it my-app /bin/sh

🍕 Real-world example:

Your app throws "connection refused" to the database. But the database container IS running. What's happening?

# 1. Jump into the app container
docker exec -it my-app /bin/sh

# 2. Test the connection from INSIDE the container
ping db-host
# or
curl http://db-host:5432
# or
nc -zv db-host 5432

If ping works from inside the container but your app can't connect, it's a config problem, not a networking problem. You just narrowed it down in 30 seconds.

The -it flags:

-i = interactive (keeps STDIN open)
-t = pseudo-TTY (gives you a proper terminal)

Without both, you get a broken shell. Always use both together.

🔍 3) `docker logs` — See what's actually happening

Your container crashed. No error message on your screen. Where did it go?

# Show all logs
docker logs my-app

# Follow logs in real-time (like tail -f)
docker logs -f my-app

# Last 100 lines
docker logs --tail 100 my-app

# Logs from the last 5 minutes
docker logs --since 5m my-app

# Logs with timestamps
docker logs -t my-app

🧠 Combine for debugging:

# Watch real-time logs with timestamps, last 50 lines
docker logs -f -t --tail 50 my-app

# Search logs for errors
docker logs my-app 2>&1 | grep -i error

# Save logs to a file
docker logs my-app > app.log 2>&1

Use it when: container exits unexpectedly, debugging API responses, checking startup errors, monitoring request flow.

🏗️ 4) Multi-stage builds — Shrinking your images by 90%

This is the single biggest optimization most Dockerfiles miss.

# ❌ Bad — final image includes ALL build tools
FROM node:20
WORKDIR /app
COPY . .
RUN npm install
RUN npm run build
CMD ["node", "dist/index.js"]
# Image size: ~1.2GB

# ✅ Good — multi-stage build
FROM node:20 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-slim
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
CMD ["node", "dist/index.js"]
# Image size: ~180MB

🤔 What's happening here?

Stage 1 (builder): Full Node.js image. Has compilers, build tools, dev dependencies. Builds your app.

Stage 2 (runtime): Slim image. Only copies the BUILD OUTPUT from stage 1. No compilers. No source code. No dev dependencies.

The final image only contains what it needs to RUN, not what it needed to BUILD.

You can have as many stages as you want:

FROM node:20 AS deps
COPY package*.json ./
RUN npm ci

FROM node:20 AS builder
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build

FROM node:20-slim AS runtime
COPY --from=builder /app/dist ./dist
COPY --from=deps /app/node_modules ./node_modules
CMD ["node", "dist/index.js"]

🔗 5) `docker network` — Make containers talk to each other

Containers are isolated by default. They can't see each other unless you connect them.

# Create a network
docker network create my-network

# Run containers on the same network
docker run -d --name api --network my-network my-api
docker run -d --name db --network my-network postgres

# Now "api" can reach "db" by name:
# postgres://db:5432/mydb

🧠 Why this matters

When you use docker-compose, it creates a network automatically. But when running docker run manually, containers are on the default bridge network where DNS resolution by name doesn't work.

# ❌ This won't work on default bridge
docker run my-app curl http://db:5432

# ✅ This works
docker network create app-net
docker run --network app-net --name db postgres
docker run --network app-net my-app curl http://db:5432

Inspect a network:

docker network inspect my-network
# Shows all connected containers and their IPs

Use it when: running multiple containers that need to communicate, debugging network issues, setting up microservices locally.

🛡️ 6) `.dockerignore` — Stop sending your entire disk to Docker

When you run docker build ., Docker sends your ENTIRE directory as context to the daemon. Including node_modules. Including .git. Including that 4GB video file.

# .dockerignore
node_modules
.git
.gitignore
*.md
.env
.env.local
docker-compose*.yml
Dockerfile
.dockerignore
coverage
.nyc_output
.vscode
.idea
*.log
tmp

🧠 Why this matters

Without .dockerignore:

Sending build context to Docker daemon  2.34GB

With .dockerignore:

Sending build context to Docker daemon  12.4MB

That's not just faster builds. Some files like .env contain secrets. You don't want those baked into your image layers where anyone with image access can read them.

# Verify what Docker can see
docker build --no-cache -t test . 2>&1 | head -5
# Check the "Sending build context" line

📦 7) `docker compose watch` — Live reload in development

This one is new and it's amazing for development.

# docker-compose.yml
services:
  web:
    build: .
    ports:
      - "3000:3000"
    develop:
      watch:
        - action: sync
          path: ./src
          target: /app/src
        - action: rebuild
          path: package.json

# Start with watch mode
docker compose watch

🤔 What's happening?

sync: When files in ./src change, they're copied INTO the running container. No rebuild needed. Your app hot-reloads.

rebuild: When package.json changes, the entire container is rebuilt (because dependencies changed).

Before this, you had to choose between:

Bind mounts (fast but breaks on macOS/Windows with file system differences)
Manual rebuilds (slow and annoying)

docker compose watch gives you the best of both.

🧬 8) `docker inspect` — The x-ray machine

When you need to know EVERYTHING about a container, image, network, or volume:

# Full JSON dump
docker inspect my-container

# Get a specific value
docker inspect --format='{{.State.Status}}' my-container
# running

docker inspect --format='{{.NetworkSettings.IPAddress}}' my-container
# 172.17.0.2

docker inspect --format='{{json .Mounts}}' my-container
# [{"Type":"bind","Source":"/home/user/data","Destination":"/app/data"}]

docker inspect --format='{{.Config.Env}}' my-container
# [PATH=/usr/local/sbin:... DATABASE_URL=postgres://...]

🍕 Useful inspection combos:

# What port is exposed?
docker inspect --format='{{json .NetworkSettings.Ports}}' my-app

# What image was this container built from?
docker inspect --format='{{.Config.Image}}' my-app

# When was it created?
docker inspect --format='{{.Created}}' my-app

# What's the restart policy?
docker inspect --format='{{.HostConfig.RestartPolicy.Name}}' my-app

Use it when: debugging networking, checking environment variables, verifying volume mounts, finding container configuration.

🔄 9) `docker compose` profiles — Conditional services

You don't always need Redis, Elasticsearch, and Mailhog. Start only what you need.

# docker-compose.yml
services:
  api:
    build: .
    ports:
      - "3000:3000"

  db:
    image: postgres:16
    profiles: ["database"]

  redis:
    image: redis:7
    profiles: ["cache"]

  elasticsearch:
    image: elasticsearch:8
    profiles: ["search"]

  mailhog:
    image: mailhog/mailhog
    profiles: ["email"]

# Start only api + db
docker compose --profile database up

# Start api + db + redis
docker compose --profile database --profile cache up

# Start EVERYTHING
docker compose --profile database --profile cache --profile search --profile email up

Without --profile, only non-profiled services start (just api in this case).

Use it when: different team members need different stacks, CI needs minimal services, you want fast local startup for daily development.

🧪 10) `docker buildx` — Build for any platform

Need to build an image for ARM (Raspberry Pi, M1/M2 Mac) but you're on x86?

# Create a multi-platform builder
docker buildx create --name multiarch --use

# Build for multiple platforms at once
docker buildx build   --platform linux/amd64,linux/arm64,linux/arm/v7   -t my-app:latest   --push   .

🧠 What's happening?

buildx uses QEMU emulation to build for architectures your machine doesn't have. The --push flag sends the multi-platform manifest to your registry.

When someone pulls my-app:latest, Docker automatically picks the right architecture:

# On M1 Mac → pulls arm64
docker pull my-app:latest

# On x86 server → pulls amd64
docker pull my-app:latest

Build for Raspberry Pi from your laptop:

docker buildx build   --platform linux/arm/v7   -t my-app:pi   --load   .

--load loads it into your local Docker (instead of pushing to a registry). Note: can only load one platform at a time locally.

🧠 TL;DR Cheat Sheet

Command	What it does	Use when
`docker system prune -a`	Clean all unused data	Disk full
`docker exec -it <c> sh`	Shell into container	Debugging
`docker logs -f <c>`	Stream container logs	Monitoring
Multi-stage builds	Shrinks image 90%	Production
`docker network create`	Connect containers	Microservices
`.dockerignore`	Exclude files from build	Every build
`docker compose watch`	Live reload in dev	Development
`docker inspect`	Full container details	Debugging
Compose profiles	Conditional services	Flexible stacks
`docker buildx`	Cross-platform builds	ARM/Pi/M1

🏁 Docker isn't magic. It's just Linux.

Every container is just a Linux process with namespace isolation and cgroup limits. That's it. There's no virtual machine. There's no magic.

Once you understand that, Docker stops being scary. It becomes a tool you control instead of a tool that controls you.

Stop memorizing commands. Start understanding what they do.

Tags: #docker #devops #webdev #programming

10 console tricks every JavaScript dev should know in 2026 🧪

mamoor123 — Sat, 18 Apr 2026 21:25:44 +0000

🔥 This is not console.log()

Seriously.

Every junior dev learns console.log() on day one. And then they never learn anything else.

That's like learning to use a hammer and ignoring the entire toolbox.

The browser console is one of the most powerful debugging environments in existence. And 95% of developers only use it to print strings.

Let's fix that.

🎯 1) `console.table()` — Display data as a real table

Stop printing arrays as [object Object],[object Object].

const users = [
  { name: "Ada", role: "Engineer", level: 5 },
  { name: "Linus", role: "Architect", level: 8 },
  { name: "Grace", role: "Lead", level: 7 },
];

// ❌ Old way
console.log(users);
// [{...}, {...}, {...}]  — useless

// ✅ New way
console.table(users);

This prints a clean, sortable table right in your console. With columns. And row numbers.

🧠 What's actually happening?

console.table() takes an array of objects (or an object) and renders it as a formatted table. Each object property becomes a column. Each array item becomes a row.

You can also pick which columns to show:

// Only show name and level
console.table(users, ["name", "level"]);

Works with plain objects too:

console.table({ a: 1, b: 2, c: 3 });
// Shows index | key | value

Use it when: inspecting API responses, checking arrays of data, comparing config objects, debugging state.

⚡ 2) `console.group()` and `console.groupCollapsed()` — Organize your logs

Your console looks like a mess? That's because you haven't grouped anything.

console.group("🔄 User Login Flow");
console.log("1. Validating input...");
console.log("2. Sending API request...");
console.log("3. Response received:", { status: 200 });
console.groupEnd();

This creates a collapsible group in the console. Click to expand/collapse.

console.groupCollapsed() does the same thing but starts collapsed:

console.groupCollapsed("📦 Loading user preferences");
console.log("Theme: dark");
console.log("Language: en");
console.log("Notifications: enabled");
console.groupEnd();

🍕 Real-world example:

function processOrder(order) {
  console.group("🛒 Processing order #" + order.id);

  console.group("💰 Payment");
  console.log("Method:", order.paymentMethod);
  console.log("Amount:", order.total);
  console.groupEnd();

  console.group("📦 Items");
  order.items.forEach(item => {
    console.log("- " + item.name + " x" + item.qty);
  });
  console.groupEnd();

  console.groupEnd();
}

Nested groups. Clean hierarchy. Your console reads like documentation instead of a wall of noise.

🎨 3) `console.log()` with CSS styling

Yes. You can style console output. Most people don't know this.

console.log(
  "%c Success! %c User created successfully",
  "background: #00b894; color: white; padding: 4px 8px; border-radius: 4px; font-weight: bold;",
  "color: #00b894; font-size: 14px;"
);

The %c placeholder applies the CSS string that follows it.

🧲 More examples:

// Error style
console.log(
  "%c ERROR ",
  "background: #d63031; color: white; padding: 4px 8px; border-radius: 4px;",
  "Something went wrong"
);

// Warning style
console.log(
  "%c WARN ",
  "background: #fdcb6e; color: black; padding: 4px 8px; border-radius: 4px;",
  "Deprecated API used"
);

// Big title
console.log(
  "%c MyApp v2.0",
  "color: #6c5ce7; font-size: 24px; font-weight: bold;"
);

Use it when: building CLI-style debugging output, branding your app's console, making errors stand out from noise.

🔍 4) `console.trace()` — See exactly where things are called

When you're deep in nested function calls and don't know WHERE something is being triggered:

function handleClick() {
  validateForm();
}

function validateForm() {
  checkEmail();
}

function checkEmail() {
  console.trace("Email validation called from:");
  // Shows the full call stack
}

Output:

Email validation called from:
checkEmail @ app.js:42
validateForm @ app.js:30
handleClick @ app.js:15
(anonymous) @ app.js:5

No more guessing. You see the exact path from root to current call.

Use it when: debugging event handlers, tracing callback chains, finding which code path triggered a function, understanding complex flows.

⏱️ 5) `console.time()` — Measure how long things take

Stop guessing if your code is slow. Measure it.

console.time("API Call");

fetch("/api/users")
  .then(res => res.json())
  .then(data => {
    console.timeEnd("API Call");
    // API Call: 234.56ms
  });

🧠 With labels for multiple timers:

console.time("Total");
console.time("Database");

// ... database query ...
console.timeEnd("Database");
// Database: 45.23ms

console.time("Render");

// ... rendering ...
console.timeEnd("Render");
// Render: 12.87ms

console.timeEnd("Total");
// Total: 58.10ms

You can run multiple timers simultaneously with different labels. No libraries. No performance.now() boilerplate.

Use it when: comparing algorithm speeds, measuring API latency, profiling render times, benchmarking loops.

🛡️ 6) `console.assert()` — Log only when something is wrong

This one is criminally underused.

const user = { name: "Ada", age: -5 };

// Only prints if the condition is FALSE
console.assert(user.age > 0, "Age must be positive! Got:", user.age);
// Output: Assertion failed: Age must be positive! Got: -5

console.assert(user.name, "Name is missing!");
// Nothing — assertion passed

🤔 Why this matters

Instead of:

if (!condition) {
  console.log("something is wrong");
}

You write:

console.assert(condition, "something is wrong");

One line. Same behavior. Cleaner code.

Use it when: validating data shapes, checking preconditions, defensive programming, sanity checks during development.

🧹 7) `console.count()` — Count how many times something runs

function handleRequest(req) {
  console.count("Request received");
  // ... process ...
}

// After running 5 times:
// Request received: 1
// Request received: 2
// Request received: 3
// Request received: 4
// Request received: 5

Reset the counter:

console.countReset("Request received");

🍕 Real-world example:

// How many times is this re-render happening?
function MyComponent() {
  console.count("MyComponent render");
  return <div>Hello</div>;
}

// If you see the count climbing fast, you have a re-render problem.

Use it when: detecting infinite loops, counting re-renders, tracking function calls, finding performance bottlenecks.

💀 8) `console.warn()` and `console.error()` — Different severity levels

Stop using console.log() for everything.

// Informational
console.log("User logged in");

// Something might be wrong
console.warn("API response took 3000ms — consider caching");

// Something IS wrong
console.error("Failed to fetch user:", error);

🧠 Why this matters

console.warn() shows a yellow icon and stack trace
console.error() shows a red icon, stack trace, AND breaks on error if DevTools is set to "Pause on exceptions"
You can filter by level in DevTools (show only errors, hide info, etc.)

Your logs become searchable and filterable instead of a wall of identical white text.

// In the DevTools console filter:
// -error     → hides all errors
// warn       → shows only warnings
// -log       → hides all regular logs

🪄 9) `console.dir()` — Inspect DOM elements as objects

When you console.log() a DOM element, you get the HTML tree. Sometimes you want the JavaScript object instead.

const button = document.querySelector("#submit");

// Shows HTML representation
console.log(button);
// <button id="submit">Submit</button>

// Shows the JS object with all properties
console.dir(button);
// ▶ HTMLButtonElement
//   - id: "submit"
//   - className: "btn-primary"
//   - dataset: DOMStringMap { ... }
//   - style: CSSStyleDeclaration { ... }
//   - ... hundreds more properties

Use it when: inspecting DOM properties, checking dataset values, debugging element state, exploring event listeners.

🧪 10) The `$` shortcuts in DevTools

These aren't console methods — they're DevTools built-in shortcuts that most people never learn.

// Last console result
$0  // Currently selected element in Elements panel
$1  // Previously selected element
$2  // Two selections ago
$3
$4

// jQuery-like selectors (native, no jQuery needed)
$$("div")          // Returns array of all divs
$("div.container") // Returns first match (like querySelector)
$x("//button")     // XPath selector

// Quick access
$_  // Last expression result

🧊 The power combo:

// 1. Click an element in the Elements panel
// 2. In console, type:
$0.style.outline = "3px solid red"
// → That element now has a red outline

// 3. Get all buttons on the page
$$("button").map(b => b.textContent)
// → ["Save", "Cancel", "Delete", "Edit"]

// 4. Find all images with no alt text
$$("img").filter(img => !img.alt)
// → Shows accessibility violations

No more writing document.querySelectorAll() every single time.

🧠 TL;DR Cheat Sheet

Method	What it does	Use when
`console.table()`	Display as table	Inspecting arrays/objects
`console.group()`	Collapsible groups	Organizing complex logs
`console.log("%c...", css)`	Styled output	Making logs readable
`console.trace()`	Print call stack	Finding where code runs
`console.time()`	Measure duration	Benchmarking performance
`console.assert()`	Log on failure	Validation checks
`console.count()`	Count executions	Detecting loops/re-renders
`console.warn()` / `error()`	Severity levels	Filtering important logs
`console.dir()`	Inspect as object	DOM element debugging
`$0`, `$$()`, `$_`	DevTools shortcuts	Quick element access

🏁 Your console is a debugger, not a notepad

The next time you're about to type console.log(something) — stop.

Ask yourself:

Is this an array? → console.table()
Is this a performance issue? → console.time()
Is this a conditional check? → console.assert()
Is this a complex flow? → console.group()
Do I need to find where this is called? → console.trace()

Your console can do so much more than print strings. Start using it properly.

Your debugging speed will 10x. Not exaggerating.

10 CSS tricks that feel illegal to know in 2026 🤫

mamoor123 — Sat, 18 Apr 2026 20:59:10 +0000

🧊 Hey, quick story

Last week I watched a senior dev write 47 lines of JavaScript.

To center a div.

He wasn't joking.

look, CSS has changed. A LOT. Most tutorials still teach you the 2019 way of doing things. The stuff I'm about to show you? It makes old approaches look like cave paintings.

let's go.

🎯 1) `:has()` — The selector CSS never had (until now)

This is the one people lose their minds over.

:has() lets a parent react to its children. CSS couldn't do this before. At all.

/* Style the card ONLY if it contains an image */
.card:has(img) {
  padding: 0;
}

/* Highlight a form group that has an invalid input */
.form-group:has(input:invalid) {
  border: 2px solid red;
}

/* Style a list item that contains a highlighted span */
li:has(span.highlight) {
  background: yellow;
}

🧠 What's actually happening here?

Before :has(), you needed JavaScript. You'd do something like:

// Old way — painful
document.querySelectorAll('.card').forEach(card => {
  if (card.querySelector('img')) {
    card.style.padding = '0';
  }
});

Now? One CSS line. No JS. No DOM queries. The browser handles it.

Real use case: You have a notification bar. Only show it if there's actual content inside:

.notification-bar:has(p) {
  display: flex;
}

No display: none toggle logic. The CSS knows.

⚡ 2) `container queries` — Responsive without the viewport

Media queries check the screen size. Container queries check the parent size.

That's a massive difference.

/* The container */
.card-wrapper {
  container-type: inline-size;
  container-name: card;
}

/* When the CONTAINER is wider than 400px */
@container card (min-width: 400px) {
  .card {
    display: flex;
    gap: 1rem;
  }
}

/* When the CONTAINER is narrower */
@container card (max-width: 399px) {
  .card {
    flex-direction: column;
  }
}

🍕 Real-world example:

Imagine a dashboard. Sidebar is 300px. Main area stretches. You have the same widget component in BOTH areas.

With media queries, the widget only knows about the screen. It doesn't care if it's sitting in a 300px sidebar or a 900px main area.

With container queries, the widget adapts to wherever it's placed. Same component. Different layouts. Automatically.

┌─────────────┬──────────────────────────────┐
│             │                              │
│  widget     │         widget               │
│  (stacked)  │    (side-by-side)            │
│             │                              │
│  300px wide │         900px wide           │
└─────────────┴──────────────────────────────┘

This is the future of responsive design. Start using it today.

🧹 3) `text-wrap: balance` — Fix ugly headings

You know when a heading wraps and one line has 3 words and the next has 1? It looks terrible.

/* Before: uneven lines */
h1 {
  /* "How to Build a Modern"  */
  /* "Website"               */
}

/* After: balanced! */
h1 {
  text-wrap: balance;
  /* "How to Build a"        */
  /* "Modern Website"        */
}

That's it. One property. Your headings instantly look like they were designed by someone who cares.

Bonus: text-wrap: pretty does something similar for paragraph text — it avoids orphaned words at the end of paragraphs.

p {
  text-wrap: pretty;
}

No more JavaScript libraries for this. No more hacky   tricks. Native CSS.

🎨 4) `accent-color` — Style native checkboxes and radios

You've probably built entire custom checkbox components in React. 200 lines of code. For a checkmark.

/* Just... do this instead */
input[type="checkbox"] {
  accent-color: #6c5ce7;
  width: 20px;
  height: 20px;
}

input[type="radio"] {
  accent-color: #00b894;
}

input[type="range"] {
  accent-color: #e17055;
}

🤔 Why this matters

Native form elements are:

Accessible by default (keyboard, screen readers)
Fast (no re-renders)
Consistent across platforms

Custom components break all of this unless you're extremely careful.

accent-color gives you the branding you want WITHOUT rebuilding accessibility from scratch.

Works on checkboxes, radio buttons, range sliders, and progress bars.

🔥 5) `aspect-ratio` — No more padding hacks

For YEARS, maintaining aspect ratios required this monstrosity:

/* The old padding-top hack — don't do this */
.video-wrapper {
  position: relative;
  padding-bottom: 56.25%; /* 16:9 */
  height: 0;
}
.video-wrapper iframe {
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
}

Now?

.video-wrapper {
  aspect-ratio: 16 / 9;
  width: 100%;
}

/* Or for a square */
.avatar {
  aspect-ratio: 1;
  width: 100px;
}

/* Or auto (uses the image's natural ratio) */
img {
  aspect-ratio: auto;
  width: 100%;
}

One line. Works on any element. Images, videos, divs, iframes — anything.

Use it for: thumbnail grids, video embeds, profile photos, card images, canvas elements.

🎭 6) `scroll-driven animations` — No JavaScript scroll listeners

This one is brand new and it's wild.

You can now create scroll-based animations purely in CSS. No addEventListener('scroll'). No Intersection Observer. No requestAnimationFrame.

/* Element fades in as you scroll it into view */
.fade-in {
  animation: fadeIn linear both;
  animation-timeline: view();
  animation-range: entry 0% entry 100%;
}

@keyframes fadeIn {
  from {
    opacity: 0;
    transform: translateY(30px);
  }
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

/* Progress bar that fills as you scroll the page */
.progress-bar {
  position: fixed;
  top: 0;
  left: 0;
  height: 4px;
  background: #6c5ce7;
  transform-origin: left;
  scaleX(0);

  animation: growBar linear both;
  animation-timeline: scroll();
}

@keyframes growBar {
  to { scaleX(1); }
}

🧊 What's happening here?

animation-timeline: view() ties the animation to when the element is visible in the viewport. As you scroll it into view, the animation plays.

animation-timeline: scroll() ties it to the overall page scroll position.

animation-range controls WHEN during that scroll the animation starts and ends.

Before this, you'd need something like GSAP ScrollTrigger or AOS.js. Now it's native. In CSS. The performance is insane because the browser handles it compositor-side.

🛡️ 7) `color-mix()` — Dynamic colors without a preprocessor

Need a lighter version of your brand color? A darker hover state? An overlay?

/* Mix your brand color with white (lighter) */
.card:hover {
  background: color-mix(in srgb, #6c5ce7, white 30%);
}

/* Mix with black (darker) */
.button:active {
  background: color-mix(in srgb, #00b894, black 20%);
}

/* Mix two colors together */
.mixed {
  color: color-mix(in srgb, #e17055, #6c5ce7 50%);
}

/* Mix with transparency */
.overlay {
  background: color-mix(in srgb, #2d3436, transparent 50%);
}

🧠 Why this is a big deal

Before color-mix(), you either:

Used Sass/Less (extra build step)
Manually calculated hex values
Used hsl() and did mental math

Now? You just say "give me this color mixed 30% with white." The browser calculates it. No preprocessor needed.

Pro tip: Use it with CSS custom properties:

:root {
  --brand: #6c5ce7;
}

.card {
  background: color-mix(in srgb, var(--brand), white 80%);
}
.card:hover {
  background: color-mix(in srgb, var(--brand), white 60%);
}
.card:active {
  background: color-mix(in srgb, var(--brand), black 10%);
}

One brand color. Three shades. Zero hex math.

📐 8) `subgrid` — Align children across nested grids

This one solves a problem that's been driving layout nerds insane for years.

You have a grid of cards. Each card has a title, description, and button. You want the titles to align across all cards, even if they're different lengths.

/* Parent grid */
.cards {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  gap: 1.5rem;
}

/* Each card is ALSO a grid — but uses subgrid for rows */
.card {
  display: grid;
  grid-template-rows: subgrid;
  grid-row: span 3; /* title + description + button */
}

/* Now ALL titles align. ALL descriptions align. ALL buttons align. */

👀 Visual comparison

Without subgrid:

┌──────────────┐  ┌──────────────────────┐
│ Short Title  │  │ A Much Longer Title   │
│              │  │ That Wraps            │
│ desc...      │  │ desc...               │
│              │  │                       │
│ [Button]     │  │ [Button]              │
└──────────────┘  └──────────────────────┘
  ↑ misaligned      ↑ buttons don't line up

With subgrid:

┌──────────────┐  ┌──────────────────────┐
│ Short Title  │  │ A Much Longer Title   │
│              │  │ That Wraps            │
├──────────────┤  ├──────────────────────┤  ← all titles same height
│ desc...      │  │ desc...               │
│              │  │                       │
├──────────────┤  ├──────────────────────┤  ← all descriptions same height
│ [Button]     │  │ [Button]              │
└──────────────┘  └──────────────────────┘  ← all buttons aligned

The child grid inherits the parent's row tracks. Everything lines up. No magic numbers. No flex hacks.

🧪 9) `@layer` — Control specificity without fighting it

The #1 cause of !important abuse? Specificity wars.

@layer lets you declare which stylesheets take priority.

/* Define layer order — first = lowest priority */
@layer reset, base, components, utilities;

/* Reset layer — lowest priority */
@layer reset {
  * { margin: 0; padding: 0; }
}

/* Base layer */
@layer base {
  body { font-family: system-ui; color: #333; }
}

/* Components layer */
@layer components {
  .button {
    background: #6c5ce7;
    color: white;
    padding: 0.5rem 1rem;
  }
}

/* Utilities layer — highest priority */
@layer utilities {
  .bg-red {
    background: red !important; /* this actually works cleanly now */
  }
}

🧠 What this means

Styles outside any layer ALWAYS beat styles inside layers. So your framework's styles (in a layer) can't accidentally override your custom styles (outside layers).

/* This beats everything in @layer — even if the layer rule uses !important */
.my-button {
  background: black;
}

Perfect for: third-party CSS frameworks, design systems, team projects where people keep overriding each other's styles.

🪄 10) `@scope` — Truly scoped CSS (no more BEM wars)

BEM. CSS Modules. CSS-in-JS. Tailwind. All of these exist because CSS doesn't scope by default.

Now it does.

@scope (.card) {
  :scope {
    border: 1px solid #ddd;
    border-radius: 8px;
    padding: 1rem;
  }

  h2 {
    font-size: 1.25rem;
    color: #2d3436;
  }

  p {
    color: #636e72;
    line-height: 1.6;
  }
}

🤔 What's happening?

Everything inside @scope (.card) only applies to elements inside .card. The h2 rule won't leak out and style every h2 on the page.

:scope refers to the .card element itself.

You can even set scope boundaries:

/* Don't style anything inside .card .sidebar */
@scope (.card) to (.sidebar) {
  p { color: #333; }
  /* This p style WON'T apply inside .card .sidebar */
}

No build step. No naming convention. No runtime cost. Just actual scoped CSS. Finally.

🧠 TL;DR Cheat Sheet

Trick	What it kills	Support
`:has()`	JS parent selectors	✅ All modern browsers
`container queries`	Media query hacks	✅ All modern browsers
`text-wrap: balance`	Ugly heading wraps	✅ Chrome, Edge, Safari
`accent-color`	Custom checkbox libraries	✅ All modern browsers
`aspect-ratio`	Padding-top hack	✅ All modern browsers
`scroll-driven animations`	GSAP/AOS scroll JS	✅ Chrome, Edge (Safari soon)
`color-mix()`	Sass color functions	✅ All modern browsers
`subgrid`	Flexbox alignment hacks	✅ All modern browsers
`@layer`	!important abuse	✅ All modern browsers
`@scope`	BEM / CSS Modules	✅ Chrome, Edge (Safari soon)

🏁 Stop writing JavaScript for CSS problems

Half the "CSS is broken" takes come from people who learned CSS in 2018 and never looked back.

CSS in 2026 is a different language. Scoped styles. Container awareness. Scroll animations. Parent selectors. Color math. All native. Zero dependencies.

The next time you reach for a JavaScript library to do something visual... check if CSS already does it.

It probably does.

🌍 Planetary Pulse — AI-Powered Earth Dashboard with 6 Prize Tech Integrations

mamoor123 — Sat, 18 Apr 2026 11:24:51 +0000

This is a submission for Weekend Challenge: Earth Day Edition

What Inspired Me

Last month I scrolled past three climate headlines before breakfast. Record heat. Melting ice. Endangered species. Each one felt like a notification from a planet I'd muted.

The problem isn't data — we have more climate data than ever. The problem is that data doesn't talk to you. It shows you a chart, you nod, you scroll on. What if the data knew you? What if it said "you specifically could cut 1.5 tonnes by switching your electricity provider" instead of "global temperatures rose 0.1°C"?

I looked at what exists: dozens of carbon calculators, climate dashboards, eco trackers. They all follow the same pattern — fill out a form, get a number, feel guilty, close the tab. Nobody remembers what you told them last time. Nobody shows you the actual planet data alongside your personal impact. Nobody lets you do something about it that's verifiably real.

I wanted to build something different: not a calculator, but a planetary health companion — one that sees the global picture, knows your personal habits, talks to you like it remembers you (because it does), and lets you take verified action that lives on a blockchain.

What I Built

Planetary Pulse isn't a carbon calculator with a fancy UI. It's four interconnected systems that work together:

A planetary health dashboard fed by 7 real climate datasets from NASA, NOAA, NSIDC, IRENA, and WWF — spanning 144 years (1880–2024)
An AI assistant with persistent memory that learns your habits across sessions and gives you personalized insight, not generic tips
A carbon calculator calibrated to IPCC AR6 emission factors with 8 transport modes and 5 diet types
A blockchain-verified carbon credit marketplace where every retirement is a real Solana transaction you can verify on Explorer

Planetary health dashboard: health score ring, 7 real climate metrics, animated globe, temperature trend chart since 1880, and AI-powered insights

This is not "here's your carbon number." This is "here's what's happening to the planet, here's what it means for you specifically, here's what you can do, and here's blockchain proof that you did it."

Demo

🌍 Live Demo: https://planetary-pulse-fgdk.onrender.com

Works with zero API keys — all integrations have realistic mock fallbacks. No broken demos, no "it works on my machine."

Four Interconnected Tabs

The AI remembers you. Tell it "I drive an EV" once and it remembers forever — across sessions, across devices. That's Backboard persistent memory, not local storage.

IPCC AR6 calibrated calculator with 8 transport modes, 5 diet types, home energy, and consumption. Compares you against global average AND 1.5°C target.

Not a fake "offset" button. Real carbon credit projects (Amazon Reforestation, Texas Wind, Indonesia Mangrove, Direct Air Capture) with on-chain Solana retirement.

Code

📂 Source Code: https://github.com/mamoor123/Planetary-Pulse

mamoor123 / Planetary-Pulse

🌍 Planetary Pulse — AI-Powered Earth Dashboard with Backboard, Auth0, Gemini, Snowflake, Solana & GitHub Copilot

🌍 Planetary Pulse

✨ AI-Powered Earth Health Dashboard

See the planet. Understand it. Act on it.
Real-time climate data · AI-powered insights · Personal carbon tracking · Blockchain-verified credits

🚀 Quick Start · 📸 Screenshots · 🏗️ Architecture · 🛠️ Tech Stack · 🔌 API

🔥 The Problem

🌡️ +1.48°C above pre-industrial levels. 421 ppm CO₂ — highest in 3 million years. 1 million species at extinction. 10 million hectares of forest lost every year.

Climate data is everywhere. But it's disconnected, impersonal, and overwhelming. We see charts. We feel bad. We scroll on.

Planetary Pulse changes that.

💡 The Solution

🧠 From Data → Understanding

   NASA, NOAA, WWF
        │
        ▼
  ┌─────────────┐
  │  ❄️ SNOWFLAKE │ ◀── 7 climate datasets
  │  Data Lake   │     1880 → 2024
  └──────┬──────┘
         │
         ▼
  ┌─────────────┐
  │  ✨ GEMINI   │ ◀── AI interprets the numbers
  │  Analysis    │     "What does this mean for ME?"
  └──────┬──────┘

…

View on GitHub

git clone https://github.com/mamoor123/Planetary-Pulse.git
cd Planetary-Pulse
npm install
cp .env.example .env  # Optional — works without any keys
npm start
# Open http://localhost:3000

How I Built It

Architecture: Mock-First, API-Ready

The biggest engineering decision: every integration falls back to mock data automatically. The app tries the real API, catches any failure, and serves cached datasets with real climate values. This means:

Judges can evaluate without API keys ✅
The demo never breaks ✅
Each route file is self-contained and owns one integration

The frontend is vanilla HTML/CSS/JS — no React, no build step. I chose this deliberately: the dark theme, animated CSS globe, SVG health ring, and tab system are all hand-coded. You don't need a framework to ship something polished.

🟣 Backboard — The AI That Actually Remembers You

This is the feature that makes Planetary Pulse fundamentally different from every other climate app. Most AI chatbots start from zero every session. Backboard gives the assistant persistent, automatic memory.

// Create assistant with climate expertise
const assistant = await backboardFetch('/assistants', {
  method: 'POST',
  body: JSON.stringify({
    name: 'Planetary Pulse Climate Assistant',
    system_prompt: `You are a climate science expert...`,
    model: 'google/gemini-2.0-flash',
  }),
});

// Each message auto-persists state + memory
const response = await backboardFetch(`/threads/${threadId}/messages`, {
  method: 'POST',
  body: JSON.stringify({ content: message, stream: false }),
});

When the assistant says "I remember you drive an EV and follow a vegetarian diet — that already puts you ahead of ~85% of people!" — that's Backboard's auto-extraction working. The frontend displays a live "Persistent Memory" panel showing what the AI has learned about you.

No other submission has this. Every other AI chatbot in this challenge forgets you the moment you close the tab.

🟠 Auth0 for Agents — Security That Delegates

Auth0 handles user login and mints scoped tokens for the AI agent. Most AI demos skip auth entirely — this one doesn't.

app.use(auth({
  authRequired: false,
  auth0Logout: true,
  baseURL: 'http://localhost:3000',
  clientID: process.env.AUTH0_CLIENT_ID,
  issuerBaseURL: `https://${process.env.AUTH0_DOMAIN}`,
}));

// Scoped agent token for AI delegation
app.get('/api/auth/agent-token', (req, res) => {
  if (!req.oidc?.isAuthenticated()) return res.status(401).json({ error: 'Not authenticated' });
  res.json({ agent_token: req.oidc.accessToken, user_id: req.oidc.user.sub });
});

The pattern: user authenticates → delegates specific capabilities to AI via scoped tokens. The user controls what the AI can see.

🔵 Google Gemini — Structured Intelligence, Not Chatbot Vibes

I don't use Gemini as a chatbot that says "great question!" I use it as a structured analysis engine with three endpoints, each returning a specific JSON schema:

// POST /api/gemini/analyze — structured climate metric analysis
// POST /api/gemini/personal-plan — personalized action plans
// POST /api/gemini/interpret-data — human-readable data interpretation

const response = await fetch(`${GEMINI_URL}?key=${GEMINI_API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    contents: [{ parts: [{ text: analysisPrompt }] }],
    generationConfig: { temperature: 0.7, maxOutputTokens: 2048 },
  }),
});

Schema-first prompting: I define the exact JSON shape I want and Gemini reliably returns parseable output. The AI Insights panel renders directly from Gemini's structured response — no regex, no fragile text parsing.

🔷 Snowflake — Seven Real Datasets, 144 Years of Data

let sql = `SELECT year, value, source FROM ${dataset}_data WHERE 1=1`;
if (fromYear) sql += ` AND year >= ?`;
if (toYear) sql += ` AND year <= ?`;
sql += ` ORDER BY year`;

Dataset	Source	Range
Global Temperature	NASA GISS	1880–2024
CO₂ Concentration	NOAA Mauna Loa	1960–2024
Sea Level Rise	NASA/NOAA	1993–2024
Arctic Sea Ice	NSIDC	1980–2024
Tree Cover Loss	Global Forest Watch	2001–2023
Renewable Capacity	IRENA	2010–2024
Biodiversity Index	WWF/ZSL	1970–2020

🟣 Solana — Proof of Impact on Chain

When you retire a carbon credit, it's not a fake "offset!" animation. It's a real Solana transaction you can verify on Explorer.

const burnTx = new Transaction().add(
  createBurnInstruction(
    creditTokenAccount, CREDIT_MINT,
    keypair.publicKey, tonnes * 1e9
  )
);
const signature = await connection.sendTransaction(burnTx, [keypair]);

The marketplace shows four credit types with real pricing and certification standards. Each retirement updates your cumulative impact: trees planted, car miles offset, flight hours neutralized.

🟢 GitHub Copilot — The Weekend Multiplier

Copilot changed what was possible in 48 hours. Here's exactly what it handled:

Task	Without Copilot	With Copilot	Time Saved
Express route scaffolding (5 files)	~3 hours	~30 min	2.5 hrs
CSS globe animation + pulse rings	~2 hours	~20 min	1.7 hrs
SVG health ring with gradients	~1.5 hours	~15 min	1.25 hrs
IPCC emission factor research	~1 hour	~10 min	50 min
Responsive CSS grid breakpoints	~1 hour	~15 min	45 min
Carbon calculator logic	~2 hours	~25 min	1.6 hrs
Total	~10.5 hours	~2 hours	~8.5 hours

I'd write a comment like // Calculate carbon footprint for car commute: distance km, days per week and Copilot would generate the full function with IPCC-calibrated factors. Without Copilot, this is a one-week project. With it, I shipped in a weekend.

Prize Categories

This submission qualifies for all six prize categories:

Category	What We Built	Key File
🟣 Best use of Backboard	AI assistant with persistent memory, auto fact extraction, cross-session state	`server/routes/backboard.js`
🟠 Best use of Auth0 for Agents	User auth + scoped agent token minting for AI delegation	`server/index.js`
🔵 Best use of Google Gemini	3 structured JSON endpoints: analysis, plans, interpretation	`server/routes/gemini.js`
🔷 Best use of Snowflake	7 climate datasets (NASA, NOAA, WWF) with parameterized SQL	`server/routes/snowflake.js`
🟢 Best use of GitHub Copilot	Accelerated entire codebase: scaffolding, animations, charts, calculator	Whole project
🟣 Best use of Solana	Carbon credit marketplace with on-chain burn-for-retire	`server/routes/solana.js`

What Makes This Different

I looked at 28 other Earth Day submissions. Most fall into predictable patterns:

Pattern	Examples	What They Built
"Carbon calculator + AI tips"	EcoTrack, EcoMark, Carbon Calculator	Form → number → generic tips
"AI chatbot about nature"	Deep-Time Mirror, Voice of Earth	Chat with a nature-themed bot
"Dashboard with charts"	Various	Pretty charts, no action layer

Planetary Pulse breaks every one of these patterns:

It's not a calculator with tips — it's a planetary health dashboard where the calculator is one tab out of four
The AI remembers you — Backboard gives it cross-session memory. No other submission has this.
The blockchain is real — actual Solana transactions for carbon retirement, not a UI mockup
The data is real — 7 datasets from NASA, NOAA, WWF spanning 144 years, not mock numbers
It works everywhere — zero-config mock fallbacks mean judges never see a broken demo
Six technologies, one story — not six integrations bolted together, but six solutions to six real problems

What I Learned

Backboard's auto-extraction is the future of AI assistants. No manual memory management — it just works. Every AI app should remember users like this.
Structured output > free-form prompting. Schema-first Gemini calls produce reliable, parseable JSON every time. I'll never go back to regex-parsing chatbot responses.
Mock fallbacks aren't a hack — they're architecture. Building dual-path (live API → cached fallback) from the start made the entire app demo-proof.
Solana devnet surprised me. Expected blockchain friction, got instant transactions and a real explorer. The UX gap between "retire a credit" and "see the tx on Solana Explorer" is 3 seconds.
Copilot changed my project scope. What used to be "build a dashboard" became "build a dashboard + AI assistant + calculator + blockchain marketplace" — because the boilerplate was free.
Auth0 for Agents is the missing piece in AI apps. Most demos skip auth. Scoped tokens enable real delegation patterns where users control what the AI can access.

Future Enhancements

Real-time WebSocket data feeds from live climate APIs
Community leaderboards and shared climate goals
Mobile PWA for install-on-home-screen experience
MCP integration for the Auth0 + Backboard agent

The planet is worth building for. 🌍💚

⚡ From `git clone` to Full Company Operating System in 60 Seconds.

mamoor123 — Tue, 14 Apr 2026 18:22:44 +0000

⚡ From `git clone` to Full Company Operating System in 60 Seconds.

⏱️ Seriously. 60 Seconds.

You're a developer. You don't want to read a 40-page setup guide. You don't want to "contact sales." You don't want to configure 12 integrations before you see a dashboard.

You want to run a command and see something working.

That's exactly what HiveOps does.

git clone https://github.com/mamoor123/hiveops.git && cd hiveops
cp .env.example .env
openssl rand -base64 32  # paste into .env as JWT_SECRET
docker-compose up --build

Open http://localhost:3000. Done. 🎉

You now have a full company operating system running on your machine. Let me show you what's inside. 📦

🧠 Wait — What Did I Just Deploy?

A complete, production-ready platform that handles:

Module	What It Does
📋 Task Management	Create, assign, track — with priorities, statuses, comments, and file attachments
🤖 AI Agents	Per-department agents that autonomously execute tasks
⚙️ Workflow Engine	Triggers → Conditions → Actions. Your ops logic, automated
📧 Real Email	SMTP + IMAP. Inbox, drafts, replies. AI drafts responses for you
📚 Knowledge Base	Articles with full-text search
💬 Real-Time Chat	Channel-based messaging with Socket.IO
📊 Dashboard	Live stats on tasks, agents, emails, and workflows
🔐 Auth System	JWT tokens, role-based access, brute-force protection

All in one Docker Compose file. 🐳

🔍 What Happened in Those 60 Seconds?

Let me break down what docker-compose up actually started:

🗄️ 1. PostgreSQL 16

A full database with 14 tables — ready to go.

users | departments | agents | tasks | task_comments | messages
knowledge_base | workflows | workflow_logs | emails
notifications | uploads | scheduled_tasks | schema_migrations

No migrations to run manually. The app handles it on boot. ✅

🖥️ 2. The API Server (Node.js + Express)

Running on port 3001. Serving 12+ route modules:

# Auth
POST /api/auth/register     → Create account
POST /api/auth/login        → Get JWT token
GET  /api/auth/me           → Current user

# Tasks
GET  /api/tasks             → List tasks (filterable)
POST /api/tasks             → Create task
GET  /api/tasks/:id         → Task detail

# AI Agents
POST /api/ai/chat/:agentId        → Chat with agent
POST /api/ai/execute/:taskId      → Execute task via agent
POST /api/ai/delegate             → Agent-to-agent delegation

# Workflows
POST /api/workflows         → Create workflow
POST /api/workflows/:id/toggle    → Enable/disable

# Email
GET  /api/email/folder/:folder    → List emails
POST /api/email/send              → Send email

# Knowledge Base
POST /api/knowledge/search        → Full-text search

🎨 3. The Frontend (Next.js 14)

Running on port 3000. App Router. 12 pages covering every module.

🤖 The AI Agents — This Is Where It Gets Interesting

Most "AI integrations" are chat widgets. Type a question, get an answer. That's it.

HiveOps agents are workers. 💪

🏢 One agent per department

📣 Marketing Agent
   → system prompt: "You handle campaigns, content, and social media strategy"
   → receives tasks assigned to marketing
   → executes them autonomously

💻 Engineering Agent
   → system prompt: "You handle code reviews, deployments, and bug triage"
   → receives tasks assigned to engineering
   → executes them autonomously

🎧 Support Agent
   → system prompt: "You handle customer issues, escalations, and follow-ups"
   → receives tasks assigned to support
   → executes them autonomously

⚡ The execution loop

📥 Task assigned to agent
  → 🤖 Agent picks it up
  → ▶️ Executes with the task context
  → ✅ Success? Mark complete.
  → ❌ Failed?
       → 🔄 Retry #1 (10s delay)
       → ❌ Failed?
            → 🔄 Retry #2 (20s delay)
            → ❌ Failed?
                 → 🔄 Retry #3 (40s delay)
                 → ❌ Failed?
                      → 💀 Dead letter queue
                      → 🔔 Notify task creator

Exponential backoff. Dead letter queues. Error history tracking. This isn't a weekend project. This is production infrastructure. 🏗️

🔗 Agent delegation

Agent A can hand off a sub-task to Agent B:

🤖 Engineering Agent: "I need a deployment verification"
   → delegates to →
🤖 DevOps Agent: "Running smoke tests..."
   → reports back →
🤖 Engineering Agent: "All clear. Marking task complete."

Chain agents together for complex workflows. 🔗

⚙️ Workflow Engine — Zapier Without the Bill

Build automation rules with three components:

🔀 Triggers (when something happens)

task_created — A new task is born
task_completed — A task is done
task_updated — Someone changed a field
user_registered — New team member
schedule_daily — Runs every day

🎯 Conditions (only if...)

priority == urgent
due_date is past
field contains specific text
status == blocked
A field exists

▶️ Actions (then do this)

🔔 Notify a user, manager, or admin
📝 Update task fields
💬 Send a channel message
➕ Create a new task

Example workflow:

Trigger: task_created
Condition: priority == urgent
Action: notify manager

Trigger: schedule_daily
Condition: due_date is past
Action: notify assigned_user + update status to "blocked"

Trigger: task_completed
Condition: department == engineering
Action: create new task "Deploy to staging" for DevOps agent

Build it once. It runs forever. No per-action billing. No premium tier. 🆓

📧 Email That Actually Works

Not a "send notification" endpoint. Real email. 📬

📥 Inbox — pull emails via IMAP polling
📤 Send — SMTP outbound (Gmail, custom SMTP)
📝 Drafts — AI writes draft replies based on email context
⭐ Star & Label — organize your mail
🔍 Search — find anything
🔔 Notifications — new email? You know instantly

The agent reads incoming emails and drafts intelligent responses. Review and send. Or let it send autonomously — your call. ✍️

🛠️ Under the Hood

Backend Architecture

server/
├── src/
│   ├── config/
│   │   ├── db.js              🗄️ Dual SQLite/PostgreSQL adapter
│   │   ├── logger.js          📋 Pino structured logging
│   │   └── migrate.js         🔄 Versioned migrations
│   ├── middleware/
│   │   ├── auth.js            🔐 JWT + role-based access
│   │   ├── rateLimit.js       🛡️ Brute-force protection (login abuse)
│   │   └── validate.js        🧹 Input sanitization
│   ├── routes/                🛣️ 12 API modules
│   └── services/
│       ├── ai-engine.js       🧠 LLM integration (OpenAI-compatible)
│       ├── email-real.js      📧 SMTP + IMAP
│       ├── execution-loop.js  🔄 Retry + exponential backoff + DLQ
│       ├── scheduler.js       ⏰ DB-persisted cron jobs
│       ├── workflows.js       ⚙️ Rule engine
│       └── notifications.js   🔔 Socket.IO broadcast
└── __tests__/                 🧪 58 tests (Jest + Supertest)

Frontend

web/
├── app/                       📄 12 pages (Next.js 14 App Router)
├── components/                🧩 Shared UI components
└── lib/                       🔌 API client + auth helpers

Tests — Because We're Serious

Suite	Tests	Covers
🔐 Auth	14	Register, login, profile, password, tokens
📋 Tasks	13	CRUD, filters, comments, completion
⚙️ Workflows	8	CRUD, toggle, triggers, validation
🤖 AI	11	Chat, execution, delegation, agents
🏢 Departments	12	Departments, knowledge, email

58 tests. All passing. ✅

🗄️ Database: SQLite or PostgreSQL — Your Choice

Same API. Same code. One env var difference.

# SQLite (default — just works)
DB_PATH=./data/hiveops.db

# PostgreSQL (production scale)
DATABASE_URL=postgres://user:pass@host:5432/hiveops

Mode	Best For
🟢 SQLite	Local dev, prototyping, small teams
🔵 PostgreSQL	Production, scale, complex queries

Switch anytime. No code changes. No migrations to redo. 🔄

🧠 LLM: Works With Anything OpenAI-Compatible

# OpenAI
LLM_API_URL=https://api.openai.com/v1/chat/completions
LLM_API_KEY=sk-your-key

# Ollama (local)
LLM_API_URL=http://localhost:11434/v1/chat/completions
LLM_API_KEY=ollama

# No key? No problem.
# Simulated fallback mode works out of the box.

No vendor lock-in. Run your own models locally with Ollama. Or plug in any provider. 🔌

📊 The Numbers That Matter

Metric	Value
🐳 Docker containers	3 (Postgres + API + Web)
⏱️ Setup time	~60 seconds
📄 API routes	12 modules
🗄️ Database tables	14
🧪 Test suite	58 tests
💰 Cost	$0 forever
🔒 Data location	Your server

🎯 Who Should Use This?

🚀 Startups — Can't burn $500/mo on SaaS before you have revenue
🌍 Remote teams — One platform instead of five disconnected tabs
👩‍💻 Developers — Self-hosted > vendor-dependent
🏗️ Agencies — White-label the OS for your clients
😤 Anyone with SaaS fatigue — Time to own your stack

🔮 What's Next?

The project is alive and growing. Here's what's on the roadmap (based on the codebase):

📊 More dashboard widgets
🔌 Additional LLM provider integrations
📱 Mobile-responsive improvements
🏷️ Enhanced labeling and tagging
📈 Reporting and analytics

📜 Open Source. Fully. No Gimmicks.

No "open core." No "enterprise edition." No "contact sales." 🚫

git clone https://github.com/mamoor123/hiveops.git

⭐ Star it if you like it. 🍴 Fork it if you want to change it. 🚀 Deploy it if you need it.

🔗 github.com/mamoor123/hiveops

📌 Quick Links

Link	Description
📖 README	Full documentation
🐛 Issues	Bugs & feature requests
🧪 Tests	58 tests
🐳 Docker	Compose file

🐝 From git clone to full company OS. One command. 60 seconds. Zero dollars.

Tags: opensource, selfhosted, ai, docker, devops, productivity, nodejs, nextjs

🚀 Your Data. Your Server. Your Agents. Zero SaaS Bills.

mamoor123 — Tue, 14 Apr 2026 18:03:53 +0000

🚀 Your Data. Your Server. Your Agents. Zero SaaS Bills.

💸 The SaaS Tax Is Real

Let's do some quick math. 🧮

🗂️ Trello for tasks — $10/user/mo
📝 Notion for docs — $10/user/mo
📧 Gmail + Google Workspace — $7/user/mo
⚡ Zapier for automation — $30+/mo
🤖 An AI chatbot tool — $20+/user/mo

A 10-person team is spending $400–700/month just to manage work. That's $5,000–8,000/year on tools that don't even talk to each other.

Five tabs. Five bills. Five places where context goes to die. 💀

What if you replaced all of it with one thing you run yourself?

That's HiveOps. 🐝

🧠 What Is HiveOps?

HiveOps is an open-source, AI-powered company operating system. It's not another chatbot wrapper. It's not a toy project. It's a full-stack application that handles:

Feature	Description
✅ Task Management	Priority levels, status tracking, assignments
🤖 AI Agents	Per-department agents that execute tasks automatically
⚙️ Workflow Automation	Triggers, conditions, and actions
📧 Real Email	SMTP + IMAP — not a mock
📚 Knowledge Base	Full-text search across articles
💬 Real-Time Chat	Socket.IO with typing indicators
📊 Dashboard	Live stats and insights
🔐 Auth	JWT with role-based access control

And it runs in one Docker container on your own server. 🐳

🔥 The Killer Feature: AI Agents That Actually Work

Most "AI tools" are chatbots. You type a question, they type an answer. That's not automation. That's a search engine with extra steps. 😤

HiveOps agents are different.

🏢 Each department gets its own agent

📣 Marketing Agent → Custom system prompt, marketing context
💻 Engineering Agent → Custom system prompt, dev context
🎧 Support Agent → Custom system prompt, support context

⚡ They execute tasks autonomously

Assign a task to an agent. It runs it. Not "suggests next steps." Actually runs it.

Here's the execution loop:

📥 Task assigned to agent
  → 🤖 Agent picks it up
  → ▶️ Executes
  → ✅ Success? Mark complete.
  → ❌ Failed? 🔄 Retry (3x, exponential backoff)
  → 💀 Still failing? Dead letter queue + notify the creator

That's production-grade execution logic. Not a demo. 💪

🔗 Agents can delegate to each other

Complex workflow? Agent A can delegate a sub-task to Agent B. Your engineering agent can hand off a deployment verification to the ops agent. Chain them together.

⚙️ Workflow Automation Without the Zapier Tax

Zapier charges $30+/month for basic automation. HiveOps has it built in. Free. 💸

How it works:

Triggers 🔀 → Conditions 🎯 → Actions ▶️

🔀 Triggers	🎯 Conditions	▶️ Actions
📋 Task created	Priority is urgent	🔔 Notify manager
✅ Task completed	Due date past	📝 Update task fields
👤 User registered	Field contains text	➕ Create new task
⏰ Schedule (daily)	Status is blocked	💬 Send channel message

Build your ops logic once. It runs forever. 🔁 No per-action billing. No "premium tier required."

📧 Real Email, Not a Placeholder

A lot of "all-in-one" tools skip email. HiveOps doesn't. 🙅

📬 Full inbox — sent, drafts, starred, labels
🔄 IMAP polling — automatically pulls new mail and notifies you
📤 SMTP outbound — works with Gmail or custom SMTP servers
✍️ AI drafts replies — the agent reads the email and drafts a response
🔍 Search — find anything across your inbox

It's not a mock. It's actual email integration. 💯

🛠️ The Tech Stack (For the Builders)

HiveOps isn't a spaghetti project. Here's what's under the hood:

🖥️ Backend — Node.js + Express

server/
├── src/
│   ├── config/
│   │   ├── db.js              🗄️ Dual SQLite/PostgreSQL adapter
│   │   ├── logger.js          📋 Pino structured logging
│   │   └── migrate.js         🔄 Versioned migrations
│   ├── middleware/
│   │   ├── auth.js            🔐 JWT + role-based access
│   │   ├── rateLimit.js       🛡️ Brute-force protection
│   │   └── validate.js        🧹 Input sanitization
│   ├── routes/                🛣️ 12 API route modules
│   └── services/
│       ├── ai-engine.js       🧠 LLM integration
│       ├── email-real.js      📧 SMTP + IMAP
│       ├── execution-loop.js  🔄 Retry + backoff + DLQ
│       ├── scheduler.js       ⏰ DB-persisted cron
│       ├── workflows.js       ⚙️ Rule engine
│       └── notifications.js   🔔 Socket.IO broadcast
└── __tests__/                 🧪 58 tests (Jest + Supertest)

🎨 Frontend — Next.js 14 (App Router)

web/
├── app/                       📄 12 pages
├── components/                🧩 Shared UI
└── lib/                       🔌 API client + auth

🗄️ Database Flexibility

Same API, two backends. Switch with one env var. 🔄

Mode	When	Best for
🟢 SQLite	Default	Local dev, prototyping, <10 users
🔵 PostgreSQL	`DATABASE_URL` set	Production, scale, JSONB queries

14 tables: users, departments, agents, tasks, task_comments, messages, knowledge_base, workflows, workflow_logs, emails, notifications, uploads, scheduled_tasks, schema_migrations 📊

🧠 LLM Agnostic

Works with any OpenAI-compatible API:

🟢 OpenAI
🟡 Ollama (local models)
🔵 Any OpenAI-compatible endpoint

No vendor lock-in. No API key required — simulated fallback mode works out of the box. 📦

⚡ Setup: 60 Seconds

# 1️⃣ Clone the repo
git clone https://github.com/mamoor123/hiveops.git && cd hiveops

# 2️⃣ Copy the env file
cp .env.example .env

# 3️⃣ Generate a secret
openssl rand -base64 32  # paste into .env as JWT_SECRET

# 4️⃣ Launch everything 🚀
docker-compose up --build

Service	URL
🖥️ Dashboard	http://localhost:3000
🔌 API	http://localhost:3001
❤️ Health	http://localhost:3001/api/health

Postgres + API + Frontend. One command. 🎯

📊 The Comparison That Matters

Feature	🔴 SaaS Stack	🟢 HiveOps
💰 Cost	$50–500/mo per tool	Free. Forever.
🗄️ Data	Their servers	Your servers
🤖 AI	Separate subscription	Built-in agents
⚡ Automation	Zapier at $30+/mo	Included
🚀 Setup	Sign up, configure, integrate	`docker-compose up`
🔒 Lock-in	They own your data	You own everything

You own the code. You own the data. You own the infrastructure. 👑

🎯 Who Is This For?

🚀 Startups that can't afford $500/mo in SaaS tools before they even have revenue
🌍 Remote teams that want one platform instead of five disconnected ones
👩‍💻 Developers who prefer self-hosted over vendor-dependent
😤 Anyone tired of the SaaS tax and ready to take control

📜 Open Source. No Strings.

HiveOps is fully open source. No "open core" trickery. No "premium features" behind a paywall. No "contact sales for pricing." 🚫

git clone https://github.com/mamoor123/hiveops.git

⭐ Star it. 🍴 Fork it. 🚀 Deploy it. 👑 Own it.

🔗 github.com/mamoor123/hiveops

🐝 Stop renting your tools. Start owning them.

Tags: opensource, selfhosted, ai, productivity, devops

I Stopped Using AI Tools for 30 Days. Here's What I Learned About Myself as a Developer. 🚫🤖

mamoor123 — Sun, 12 Apr 2026 13:45:21 +0000

In January, I made a bet with myself:

No Copilot. No ChatGPT. No Claude. No AI-assisted anything for 30 days.

Not because I think AI is bad. I'm not that person.

But I noticed something creeping in — I was shipping code I couldn't fully explain. PRs went up faster, but when a colleague asked "why did you do it this way?" I'd pause. 🫠

The answer was always some version of:

"The AI suggested it. It worked."

That scared me more than any "AI will replace developers" headline ever could.

📋 Week 1:

🔥 Week 1: The Withdrawal Is Real

I felt like I was coding with one hand tied behind my back.

Everything took longer. I Googled things I hadn't Googled in months. I read docs. Actual docs. MDN became my best friend again.

But here's the thing — I understood what I was writing. Every line had a reason I could articulate.

I wasn't faster. But I was intentional. And that felt... different.

📋 Week 2:

💀 Week 2: The Uncomfortable Truth

I realized I had been outsourcing my thinking, not just my typing.

There's a terrifying difference between:

🧠 "I don't remember this syntax"
💀 "I never understood this concept"

AI had been covering for both. When you lose the crutch, you find out which one you're dealing with.

For me? It was embarrassingly the second one in more places than I'd like to admit. Async patterns I thought I knew? I was just prompting my way through them. I went back and actually learned them.

That was humbling.

📋 Week 3:

✨ Week 3: The Craft Comes Back

Something weird happened.

I started enjoying code again. 🎉

The puzzle-solving feeling. That moment when the abstraction clicks. I'd been missing it without even knowing.

I also noticed my code reviews got way better. When you write every line yourself, you have opinions about every line. When AI writes half of it, you just... approve it if the tests pass. 😅

📋 Week 4:

🔄 Week 4: I Turned AI Back On (But Different)

I'm not anti-AI. That would be stupid.

But here's what permanently changed for me:

Rule	Why
🚫 Never use AI for things I'm trying to learn	If I'm exploring a new pattern, I write it by hand first
✅ Use AI for boilerplate I've written 100x	Tests, configs, type defs — muscle memory stuff
🔒 Never accept AI code I can't explain	If a colleague asks, my answer can't be "Copilot wrote it"

📋 The Real Problem:

🎯 The Real Problem Nobody's Talking About:

Look at what's trending on dev.to right now:

😩 Burnout posts getting 200+ reactions
😰 "AI will replace us" anxiety posts with 130+ comments
🩺 People's bodies literally falling apart from sitting in chairs

Here's my take — and I'll die on this hill:

The industry isn't struggling with AI replacing developers. It's struggling with developers replacing their own judgment with AI's output.

We're not going to lose our jobs to AI.

We're going to lose our skills to AI — slowly, one accepted suggestion at a time — and then wonder why senior engineers can't debug production at 2am anymore. 🕑

The "90% AI-generated code" future? Fine.

But someone still needs to know which 10% matters, and why.

That someone should be you. 👆

📋 Self-Test Quiz:

📊 Quick Self-Test: (Be Honest)

Answer these honestly. I'll go first:

Can you write a full component/function without AI — right now, no cheating? 🤔
When was the last time you read official docs instead of asking AI to summarize them? 📖
Do you understand the code in your last PR — or just trust that it works? 🫣
If AI tools disappeared tomorrow, would your productivity drop by 10% or 80%? 📉

My honest answers:

Yes, but slower than I'd like
Last week (post-experiment). Before that? ...months.
Now I do. Before January? 😬
Probably 60%. That number used to be 20%.

📋 Closing / CTA:

💬 I Want to Hear From You

Not the diplomatic answer. The real one.

Have you noticed your skills getting sharper or softer since AI tools became the default?
What's the one thing you refuse to let AI do for you?
If you tried a 30-day AI detox — what do you think you'd discover about yourself?

Drop your honest take below. 👇 No judgment. I literally just admitted I was prompting my way through async patterns for months.

The best conversations happen when we stop pretending we've got it all figured out.

What changed for you? I'm reading every comment. 🫡

I Built an npm Package That Makes Every Function Fail — With Inspirational Quotes and Enterprise-Grade Error Boxes 🫖

mamoor123 — Fri, 10 Apr 2026 19:59:50 +0000

This is a submission for the DEV April Fools Challenge

What I Built

I got tired of boring error messages. Your TypeError: undefined is not a function has no personality. Your stack traces have no soul. Your try-catch blocks have the emotional depth of a Monday standup.

So I built dead-serious — an npm package where every single function fails. Beautifully. Enterprise-grade-ly. With inspirational quotes from tech leaders and completely useless suggested fixes.

npm install dead-serious

Yes, install it in production. I dare you. 🫖

Demo

Here is what happens when you try to do basic math:

const dead = require(dead-serious);

dead.add(2, 2);

╔══════════════════════════════════════════════════════════════╗
║  🫖  DEAD SERIOUS ERROR REPORT  🫖                          ║
╠══════════════════════════════════════════════════════════════╣
║  Timestamp:  2026-04-11 03:55:00
║  Severity:   CATASTROPHIC
║  Operation:  add(2, 2)
║  HTTP Code:  418 — I am a teapot. Short and stout. 🫖
║  Trace ID:   d748e042abac2906eab3b80c84f08cb2
╠══════════════════════════════════════════════════════════════╣
║  Message: Math module is on lunch break. 2 + 2 =
║           existential_crisis
╠══════════════════════════════════════════════════════════════╣
║  💬
║  "I will document it later."
║     — Every Developer
║  (narrator: They did not.)
╠══════════════════════════════════════════════════════════════╣
║  🔧 Suggested Fix:
║  Commit with --no-verify. What could go wrong?
╠══════════════════════════════════════════════════════════════╣
║  Status: FAILED SUCCESSFULLY ✅
╚══════════════════════════════════════════════════════════════╝

Every error comes with:

🫖 A beautifully formatted ASCII box
💬 An inspirational quote from a tech leader
🔧 A completely useless suggested fix
🆔 An enterprise-grade trace ID (generated randomly, means nothing)
📊 A severity level (CATASTROPHIC, EXISTENTIAL, BRITISH, etc.)

The Teapot Suite (RFC 7168 Compliant)

Because this challenge needs teapots:

dead.teapot();
// Error: I am a teapot. Short and stout. Here is my handle,
//        here is my spout. When I get all steamed up, hear me
//        shout: "I REFUSE TO BREW COFFEE."

dead.brewCoffee();
// Error: I am a teapot, not a coffee maker. RFC 7168 clearly
//        states I MAY brew coffee, but I CHOOSE not to.
//        Today I choose violence. 🫖

dead.brewTea();
// Error: Tea brewing is planned for v2.0. ETA: never.
//        We are pivoting to blockchain tea.

More Useless Functions

Strings Have Opinions Now

dead.concat("hello", "world");
// Error: Combined string exceeds the emotional capacity
//        of this function.

dead.split("hello", " ");
// Error: "hello" refuses to be split. It has commitment issues.

dead.trim("  spaces  ");
// Error: Trimming requires a premium subscription.
//        The spaces have feelings too.

Arrays Are On Strike

dead.sort([3, 1, 2]);
// Error: Elements cannot agree on ordering.
//        Index 1 started a rebellion.

dead.filter([1, 2, 3], x => x > 1);
// Error: No items passed the filter. Actually, no items
//        survived the filter. They are gone.

dead.map([1, 2, 3], x => x * 2);
// Error: Mapping failed. The function is allergic to arrays.

Async Fails Eventually

await dead.fetch("https://api.example.com");
// Error: Request timed out. The server is contemplating
//        its existence.

await dead.sleep(1000);
// Error: Unauthorized nap. You have not earned rest yet.
//        Go fix the bug.

dead.promise();
// Error: This Promise was broken from the start.
//        Just like my New Year resolution to write better code.

Health Check (It is Dead)

dead.healthCheck();
// {
//   status: "💀 DECEASED",
//   uptime: "0ms (it never really lived)",
//   memory: "All of it",
//   cpu: "Yes",
//   database: "¯\\_(ツ)_/¯",
//   lastGoodDay: null,
//   morale: "low",
//   teapot: true,
//   httpCode: 418
// }

Changelog for a Version That Will Never Ship

dead.changelog("2.0.0");
// ## v2.0.0
// ### Breaking Changes
// - Everything. We broke everything.
// ### New Features
// - Added 20 new ways to fail
// ### Known Issues
// - Literally everything

The Full API

Every function fails. Here is the complete menu:

Math: add(), subtract(), multiply(), divide() — All return errors

Strings: concat(), split(), trim() — All return errors

Arrays: sort(), filter(), map() — All return errors

Async: fetch(), sleep(), promise() — All return errors, eventually

Teapot: teapot(), brewCoffee(), brewTea() — RFC 7168 compliant failures

Utilities: validate(), healthCheck(), tryCatch(), changelog(), createError()

Every function has a severity level:

CATASTROPHIC, EXISTENTIAL, BRITISH, PRINCIPLED
CHAOTIC, TRAGIC, MEDICAL, PHILOSOPHICAL
PARENTAL, RELATABLE, RECURSIVE, EMOTIONAL
PERSONAL, FINANCIAL, DRAMA, VAPORWARE

How I Built It

Tech: Pure JavaScript. Zero dependencies. No frameworks. Just vibes and failure.

Architecture:

dead-serious/
├── index.js        # Every function fails (400+ lines of failure)
├── README.md       # Documentation for the undocumented
├── package.json    # Enterprise-grade metadata
└── LICENSE         # MIT (more useful than this package)

Key design decisions:

Every function throws a DeadSeriousError — a custom Error class with formatted output
20 inspirational quotes from tech leaders (all taken out of context)
20 suggested fixes (all completely unhelpful)
Severity levels include "BRITISH" and "EXISTENTIAL" — because your errors deserve personality
The healthCheck() function returns morale: "low"
Trace IDs are 32-char hex strings that mean absolutely nothing

Testing strategy: We did not write tests. That would imply the code should work. It should not.

Prize Category

🫖 Best Ode to Larry Masinter — This package is a love letter to RFC 7168 and HTTP 418. The entire teapot suite (teapot(), brewCoffee(), brewTea()) is dedicated to the legendary RFC that gave teapots a voice.

The brewCoffee() function specifically cites RFC 7168 Section 2.1: "A TEAPOT MAY brew coffee" — and chooses not to. Today it chooses violence. 🫖

Why This Exists

Because error messages deserve personality. Because "undefined is not a function" is boring. Because if your code is going to fail (and it will), it should fail with style.

Because somewhere out there, a developer is reading a stack trace at 3am and they deserve a laugh.

🫖 Be the 418 you wish to see in the world.

⭐ Star it if it made you laugh: github.com/mamoor123/dead-serious

#devchallenge #418challenge #showdev #aprilfools

I Open-Sourced a Company OS That Replaces 5 SaaS Tools — With AI Agents That Actually Do Work 🤖

mamoor123 — Fri, 10 Apr 2026 19:35:06 +0000

I was paying $600+/month for Trello + Notion + Gmail + Zapier + a chatbot tool.

Five tabs open at all times. Five subscriptions bleeding money. Five places where context went to die. 😩

One day I asked myself: what if one app did all of this — and I actually owned it?

So I built HiveOps 🐝 — an open-source company operating system with AI agents that execute real work, not just chat.

Here's why it's different from everything else out there. 👇

🚨 The Problem Nobody Talks About

Every SaaS tool solves ONE problem:

Trello → tasks
Notion → docs
Gmail → email
Zapier → automation
Chatbot → AI

But your work doesn't live in silos. A customer email becomes a task. A task triggers a workflow. A workflow notifies your team. It's all connected — except your tools aren't.

You end up copy-pasting between 5 tabs and paying for the privilege. 💸

🤖 Meet the AI Agents (This Changes Everything)

Here's what most "AI tools" actually are: a chatbot in a fancy wrapper. You ask a question. It gives an answer. You still do the work.

HiveOps agents are different. They execute tasks like real workers:

pending → execute → retry (10s) → retry (20s) → retry (40s) → dead letter queue → notify creator

That's the same retry + backoff + DLQ pattern you'd use in a production message queue. Except it's running your business operations. 🔄

The killer feature? Agents delegate to each other.

// Marketing agent needs a landing page?
// Delegate to the Engineering agent.
await agentDelegate(
  marketingAgentId,
  engineeringAgentId,
  "We need a landing page for Q2 campaign",
  taskId
);

Each agent has:

✏️ Custom system prompt (personality + instructions)
🏢 Department assignment
▶️ Auto-execution loop (picks up pending tasks automatically)
🔁 Retry logic with exponential backoff
💀 Dead letter queue after 3 failures

You assign a task to an agent → it picks it up → runs it → handles errors → notifies you if it fails. No human babysitting required.

📋 Task Management — Built for Teams AND Agents

Every task has:

🔴🟡🟠🟢 Priority levels (urgent → low)
📊 Status tracking (pending → in progress → review → completed → blocked)
👤 Assign to humans OR 🤖 AI agents
💬 Comments and file attachments
🔁 Retry tracking with error history

🔄 Workflow Automation — No Zapier Tax

The rule engine follows a dead-simple pattern:

Trigger → Condition → Action

Example workflow:

🔔 When: Task is created
✅ If: priority = urgent
⚡ Then: Notify manager → Auto-assign to ops agent → Post in #urgent channel

Three pre-built workflows come out of the box. Create your own in seconds.

📧 Real Email — Not a Mock

Inbox. Sent. Drafts. Starred. Labels. Search.

📥 IMAP polling for inbound mail
📤 SMTP for outbound
🤖 AI drafts replies based on context
🔔 Auto-notifications for new mail

Not a demo. Not a mock. Real email inside your OS.

💬 Real-Time Chat — Socket.IO

📢 Department channels
✉️ Direct messaging
🤖 Agent chat (talk to your AI workers)
⌨️ Typing indicators
🔔 Real-time notifications

🏗 Under the Hood (Architecture)

hiveops/
├── server/               # Node.js + Express
│   ├── src/
│   │   ├── services/
│   │   │   ├── ai-engine.js        # LLM integration
│   │   │   ├── execution-loop.js   # Retry + backoff + DLQ
│   │   │   ├── workflows.js        # Rule engine
│   │   │   ├── scheduler.js        # DB-persisted cron
│   │   │   └── email-real.js       # SMTP + IMAP
│   │   └── routes/                 # 12 API modules
│   └── __tests__/                  # 58 tests ✅
├── web/                  # Next.js 14 + Tailwind
└── docker-compose.yml    # Postgres + API + Web

Tech stack:

🖥️ Backend: Node.js + Express
🎨 Frontend: Next.js 14 (App Router) + React 18 + Tailwind
💾 Database: SQLite (dev) OR PostgreSQL (production) — same API, one env var switch
⚡ Real-time: Socket.IO
🔐 Auth: JWT + bcrypt + role-based access
🧠 AI: Any OpenAI-compatible API (OpenAI, Ollama, local models)

The dual-database adapter I'm most proud of — same code, both backends:

// Works on SQLite AND PostgreSQL — zero changes
const user = await db.prepare('SELECT * FROM users WHERE id = ?').get(id);
const tasks = await db.prepare('SELECT * FROM tasks WHERE status = ?').all('pending');

🔐 Self-Host = Your Data, Your Rules

	SaaS Stack	HiveOps
💰 Cost	$50-500/tool/month	Free forever
🏠 Data	Their servers	Your servers
🤖 AI	Separate subscription	Built-in
⚡ Automation	Zapier $30+/mo	Included
🐳 Setup	Sign up + configure	docker-compose up

Your tasks, emails, chat messages, and knowledge base never leave your infrastructure. 🏠

🚀 Run It in 60 Seconds

git clone https://github.com/mamoor123/hiveops.git && cd hiveops
cp .env.example .env
openssl rand -base64 32        # paste into .env as JWT_SECRET
docker-compose up --build

Open http://localhost:3000 → create account → done. 🎯

No Docker? No problem. SQLite mode works standalone:

cd server && npm install && npm run migrate
JWT_SECRET=your-secret npm run dev

🧪 It's Actually Tested

58 tests. Not "vibes-based" development:

🔐 Auth — 14 tests (register, login, profile, tokens)
📋 Tasks — 13 tests (CRUD, filters, comments)
🔄 Workflows — 8 tests (triggers, conditions, actions)
🤖 AI — 11 tests (chat, execution, delegation)
🏢 Departments — 12 tests (knowledge, email)

🧩 Full Feature List

✅ Task Management (priorities, statuses, assignments, comments, attachments)
🤖 AI Agents (auto-execution, retries, DLQ, agent-to-agent delegation)
🔄 Workflow Automation (trigger → condition → action rules)
📧 Real Email (SMTP + IMAP, AI draft replies)
💬 Real-Time Chat (Socket.IO, channels, typing indicators)
📚 Knowledge Base (full-text search, categories)
⏰ Scheduler (DB-persisted cron, auto-creates tasks)
🔐 JWT Auth + Role-Based Access (admin/member)
📊 Dashboard (live stats)

🔮 What's Coming

📱 Mobile-friendly responsive UI
📅 Calendar view for tasks
🔗 Webhook integrations
🏢 Multi-tenant support
🔐 SSO (SAML/OIDC)

💬 The Real Question

What SaaS tools are you paying for that could be one self-hosted app?

I'm genuinely curious. Drop a comment 👇 — especially if you've tried replacing a SaaS stack with something you own.

⭐ Star the repo if this was useful: github.com/mamoor123/hiveops

Built with ❤️ and a stubborn refusal to pay $600/month for things that should be free.

P.S. — If you want to contribute, all PRs welcome. Check out CONTRIBUTING.md.

I was paying $600/mo for 5 SaaS tools. So I built one that does all of them — and open-sourced it.

mamoor123 — Wed, 08 Apr 2026 11:22:42 +0000

Last year I was running a 12-person team and paying for:

📋 Trello — task management ($12/user/mo)
📝 Notion — knowledge base ($10/user/mo)
⚡ Zapier — workflow automation ($30/mo)
📧 Gmail — email (free, but 5 tabs of context switching)
🤖 Some chatbot tool — AI assistant ($50/mo)

Total: ~$600/month. Five tools. Five bills. Five places where information went to die. 😩

I kept thinking: why can't one thing do all of this? 🤔

So I built HiveOps 🐝 — a self-hosted company operating system with AI agents that actually execute tasks, not just chat.

And I open-sourced it. 🎉

🛠 What HiveOps Actually Does

It's a full-stack Node.js app that gives your team:

📋 Task Management — priority levels, status tracking, assign to users or AI agents, comments, file attachments.

🤖 AI Agents — not chatbots. Real agents that execute tasks with retry logic, exponential backoff, and a dead letter queue. Assign a task to an agent and it runs it. ⚡

🔄 Workflow Automation — event-driven rules. Trigger → Conditions → Actions. Example: "When an urgent task is created, notify the department manager and auto-assign it to an agent."

📧 Real Email — inbox, sent, drafts, starred. IMAP polling for inbound. SMTP for outbound. AI drafts replies. Not a mock — real email. ✉️

💬 Real-Time Chat — Socket.IO with typing indicators, channels, direct agent chat.

📚 Knowledge Base — full-text search, categories, CRUD.

⏰ Scheduler — DB-persisted cron. Interval, daily, weekly. Auto-creates tasks and triggers agents.

🏗 The Tech Stack

🖥️ Backend:    Node.js + Express
🎨 Frontend:   Next.js 14 (App Router) + Tailwind
💾 Database:   SQLite (dev) or PostgreSQL (production)
⚡ Real-time:  Socket.IO
🔐 Auth:       JWT + bcrypt
🧠 AI:         Any OpenAI-compatible API
📧 Email:      Nodemailer + ImapFlow
🚀 Deploy:     docker-compose up

The database adapter is the part I'm most proud of. Same API, two backends:

// This works on SQLite AND PostgreSQL — zero changes needed ✨
const user = await db.prepare('SELECT * FROM users WHERE id = ?').get(id);
const tasks = await db.prepare('SELECT * FROM tasks WHERE status = ?').all('pending');
await db.prepare('INSERT INTO users (...) VALUES (...)').run(...);

SQLite for local dev (no Docker needed 🙌). PostgreSQL for production (one env var). Auto-converts ? placeholders to $1, $2. Auto-handles boolean differences. Auto-coerces bigint strings from COUNT queries. 🔧

🤖 The AI Agent System (This Is The Interesting Part)

Most "AI agent" projects are chatbots with extra steps. HiveOps agents are different:

// 🔄 Agent auto-execution loop:
// 1. Pick pending tasks assigned to active agents
// 2. Execute via LLM with the agent's system prompt
// 3. On failure -> retry with exponential backoff (10s, 20s, 40s)
// 4. After 3 retries -> dead letter queue + notify task creator 💀

Agents can also delegate to each other 🤝:

// Agent A (marketing) delegates to Agent B (engineering)
await agentDelegate(marketingAgentId, engineeringAgentId,
  "We need a landing page for the Q2 campaign", taskId);

And the workflow engine ties it all together 🔗:

// When a task is created with priority "urgent":
// -> Check: is priority === "urgent"? ⚠️
// -> Action 1: notify the department manager 📢
// -> Action 2: auto-assign to the ops agent 🤖
// -> Action 3: send a message to the #urgent channel 💬

No Zapier. No monthly fee. Just rules that run. ✅

🚀 How to Run It

git clone https://github.com/mamoor123/hiveops.git && cd hiveops
cp .env.example .env
openssl rand -base64 32  # paste into JWT_SECRET 🔑
docker-compose up --build

Open http://localhost:3000. That's it. 🎯

Or if you don't want Docker — SQLite mode works out of the box:

cd server && npm install && npm run migrate
JWT_SECRET=your-secret npm run dev

🧠 What I Learned Building This

1️⃣ Dual-database adapters are worth the effort. Supporting SQLite + PostgreSQL from day one means devs can contribute without Docker, and you deploy with Postgres for real workloads. The adapter is ~250 lines and handles all the quirks (bigint strings, boolean differences, placeholder syntax). 🔧

2️⃣ AI agents need execution infrastructure, not just prompts. The prompt is 10% of the work. The retry logic, error handling, dead letter queues, concurrency control — that's the other 90%. 💪

3️⃣ Real-time is a superpower for internal tools. Socket.IO notifications feel alive compared to polling. Users notice the difference. ⚡

4️⃣ Open source is a force multiplier. I built this for myself, but open-sourcing it means I get bug reports, feature requests, and contributors for free. 🌍

🔮 What's Next

📱 Mobile-friendly responsive UI
📅 Calendar view for tasks
🔗 Webhook integrations
🏢 Multi-tenant support
🔐 SSO (SAML/OIDC)

⭐ Try It

GitHub: github.com/mamoor123/hiveops 🐝

Star it ⭐ if you find it useful. Open an issue 🐛 if you find a bug. PRs welcome 🙏

If you're paying for 5+ tools and your team is under 50 people — give it a spin. You might save $600/month like I did. 💰

What tools are you paying for that you wish were one thing? Drop a comment below 👇 — I'd love to hear!

I built a one-line observability decorator for Python AI agents

mamoor123 — Sun, 05 Apr 2026 12:22:02 +0000

The problem

Your AI agents break and you find out when users complain. No logs, no metrics, no idea what went wrong.

The fix

A @observe decorator that tracks every call to local SQLite. No cloud, no API key, no signup.

How it works

from agentdna import observe

@observe
def transcribe(audio):
    return whisper.transcribe(audio)

@observe
def summarize(text):
    return llm.summarize(text)
markdown
markdown
## The problem

Your AI agents break and you find out when users complain. No logs, no metrics, no idea what went wrong.

## The fix

A `@observe` decorator that tracks every call to local SQLite. No cloud, no API key, no signup.

## How it works

python
from agentdna import observe

@observe
def transcribe(audio):
return whisper.transcribe(audio)

@observe
def summarize(text):
return llm.summarize(text)
That's it. Every call is now logged with latency, success/failure, and error types.

View your stats
$ agentdna stats

📌 transcribe
✅ Healthy 42 calls ██████████ 97% avg 1250ms

📌 summarize
⚠️ Degraded 38 calls █████████░ 92% avg 3400ms
❌ 3 failures: Timeout(2), RateLimit(1)

Health thresholds:

✅ Healthy — 95%+ success rate
⚠️ Degraded — 80-95%
🔴 Unhealthy — below 80%

Features

Sync and async support
Latency percentiles (p50, p95, p99)
Error type breakdown
SQLite persistence — survives restarts
Zero dependencies beyond stdlib
Export to JSON or CSV

Install
pip install agentdna-sdk

Open source

Apache 2.0 —
GitHub

Built this because I was tired of debugging agents blind. Would love feedback!

DEV Community: mamoor123

10 Docker commands that actually matter in 2026 🐳

🐳 You're probably using Docker wrong

🎯 1) docker system prune — Clean up ALL the junk

🧠 What's actually getting deleted?

⚡ 2) docker exec -it — Jump inside a running container

🍕 Real-world example:

🔍 3) docker logs — See what's actually happening

🧠 Combine for debugging:

🏗️ 4) Multi-stage builds — Shrinking your images by 90%

🤔 What's happening here?

🔗 5) docker network — Make containers talk to each other

🧠 Why this matters

🛡️ 6) .dockerignore — Stop sending your entire disk to Docker

🧠 Why this matters

📦 7) docker compose watch — Live reload in development

🤔 What's happening?

🧬 8) docker inspect — The x-ray machine

🍕 Useful inspection combos:

🔄 9) docker compose profiles — Conditional services

🧪 10) docker buildx — Build for any platform

🧠 What's happening?

🧠 TL;DR Cheat Sheet

🏁 Docker isn't magic. It's just Linux.

10 console tricks every JavaScript dev should know in 2026 🧪

🔥 This is not console.log()

🎯 1) console.table() — Display data as a real table

🧠 What's actually happening?

⚡ 2) console.group() and console.groupCollapsed() — Organize your logs

🍕 Real-world example:

🎨 3) console.log() with CSS styling

🧲 More examples:

🔍 4) console.trace() — See exactly where things are called

⏱️ 5) console.time() — Measure how long things take

🧠 With labels for multiple timers:

🛡️ 6) console.assert() — Log only when something is wrong

🤔 Why this matters

🧹 7) console.count() — Count how many times something runs

🍕 Real-world example:

💀 8) console.warn() and console.error() — Different severity levels

🧠 Why this matters

🪄 9) console.dir() — Inspect DOM elements as objects

🧪 10) The $ shortcuts in DevTools

🧊 The power combo:

🧠 TL;DR Cheat Sheet

🏁 Your console is a debugger, not a notepad

10 CSS tricks that feel illegal to know in 2026 🤫

🧊 Hey, quick story

🎯 1) :has() — The selector CSS never had (until now)

🧠 What's actually happening here?

⚡ 2) container queries — Responsive without the viewport

🍕 Real-world example:

🧹 3) text-wrap: balance — Fix ugly headings

🎨 4) accent-color — Style native checkboxes and radios

🤔 Why this matters

🔥 5) aspect-ratio — No more padding hacks

🎭 6) scroll-driven animations — No JavaScript scroll listeners

🧊 What's happening here?

🛡️ 7) color-mix() — Dynamic colors without a preprocessor

🧠 Why this is a big deal

📐 8) subgrid — Align children across nested grids

👀 Visual comparison

🧪 9) @layer — Control specificity without fighting it

🧠 What this means

🪄 10) @scope — Truly scoped CSS (no more BEM wars)

🤔 What's happening?

🧠 TL;DR Cheat Sheet

🏁 Stop writing JavaScript for CSS problems

🌍 Planetary Pulse — AI-Powered Earth Dashboard with 6 Prize Tech Integrations

What Inspired Me

What I Built

Demo

Four Interconnected Tabs

Code

mamoor123 / Planetary-Pulse

🌍 Planetary Pulse — AI-Powered Earth Dashboard with Backboard, Auth0, Gemini, Snowflake, Solana & GitHub Copilot

🌍 Planetary Pulse

✨ AI-Powered Earth Health Dashboard

🔥 The Problem

💡 The Solution

🎯 1) `docker system prune` — Clean up ALL the junk

⚡ 2) `docker exec -it` — Jump inside a running container

🔍 3) `docker logs` — See what's actually happening

🔗 5) `docker network` — Make containers talk to each other

🛡️ 6) `.dockerignore` — Stop sending your entire disk to Docker

📦 7) `docker compose watch` — Live reload in development

🧬 8) `docker inspect` — The x-ray machine

🔄 9) `docker compose` profiles — Conditional services

🧪 10) `docker buildx` — Build for any platform

🎯 1) `console.table()` — Display data as a real table

⚡ 2) `console.group()` and `console.groupCollapsed()` — Organize your logs

🎨 3) `console.log()` with CSS styling

🔍 4) `console.trace()` — See exactly where things are called

⏱️ 5) `console.time()` — Measure how long things take

🛡️ 6) `console.assert()` — Log only when something is wrong

🧹 7) `console.count()` — Count how many times something runs

💀 8) `console.warn()` and `console.error()` — Different severity levels

🪄 9) `console.dir()` — Inspect DOM elements as objects

🧪 10) The `$` shortcuts in DevTools

🎯 1) `:has()` — The selector CSS never had (until now)

⚡ 2) `container queries` — Responsive without the viewport

🧹 3) `text-wrap: balance` — Fix ugly headings

🎨 4) `accent-color` — Style native checkboxes and radios

🔥 5) `aspect-ratio` — No more padding hacks

🎭 6) `scroll-driven animations` — No JavaScript scroll listeners

🛡️ 7) `color-mix()` — Dynamic colors without a preprocessor

📐 8) `subgrid` — Align children across nested grids

🧪 9) `@layer` — Control specificity without fighting it

🪄 10) `@scope` — Truly scoped CSS (no more BEM wars)

⚡ From `git clone` to Full Company Operating System in 60 Seconds.