voidcut

Developer portfolio

Sha Kamaldevwillsha

Backend heavy full stack engineer crafting scalable systems and the infrastructure behind bold digital experiences.

Featured build Voidcut Event-driven video editor - Go microservices
Find me online05 links
Project blueprintvoidcut

Voidcut

A smart video editor that runs in the background while you record. Logs mic and keyboard activity in real time, then uses that activity log to cut dead air after you upload the recording. Built as a full event-driven distributed microservices system in Go.

View Source on GitHub View Playlist on YouTube

The Problem

01

You record a coding tutorial

Screen recording running, you're explaining code, referring to docs on another monitor - looking back and forth.

02

Dead air accumulates

Every time you look away, pause to think, or wait for something to load - silence and stillness builds up in the recording.

03

Manual editing is painful

You spend hours scrubbing through footage cutting gaps. The ratio of editing time to recording time is brutal.

The Solution

01

Voidcut runs in the background

Before you hit record, start Voidcut. It runs silently - no UI in the way.

02

Real-time activity logging

Every mic event and keyboard/mouse event is timestamped and streamed to the ActivityLogger via NATS.

03

Upload your raw video

When recording ends, upload the video file. Voidcut already has your activity log ready.

04

Process and download

After upload, AnalysisService computes keep/cut intervals and EditingService runs FFmpeg. Download the edited video when processing is complete.

End to End Data Flow

Exactly what happens from the moment you start recording, through video upload and processing, to the moment your edited video is ready.

Recording Phase

  1. 01
    You run the agent binary

    voidcut start - launches mic listener goroutine and input listener goroutine concurrently. Connects to NATS.

    goroutinesNATS connect
  2. 02
    You start your screen recorder and begin

    Voidcut is already listening. Every time you speak or type, an event fires.

  3. 03
    Activity events stream to NATS

    Events carry: session_id, type (mic|keyboard), timestamp, duration. Published to activity.events topic.

    NATS publishactivity.events
  4. 04
    ActivityService consumes and persists

    Subscribes to activity.events. Writes each event to PostgreSQL with microsecond precision timestamps.

    NATS consumePostgreSQL insert
  5. 05
    Recording ends - you stop the agent

    SIGINT triggers graceful shutdown. Remaining events are flushed before exit, leaving the activity log ready for the later video upload.

    graceful shutdownflush

Editing Phase

  1. 06
    Upload raw video via API

    POST /api/v1/jobs with video file and session_id. API Gateway routes to VideoService.

    HTTP multipartAPI Gateway
  2. 07
    VideoService stores and emits

    Validates video, stores to disk, creates job record in PostgreSQL with status: pending. Publishes job.created to NATS.

    NATS publishjob.created
  3. 08
    AnalysisService computes cut intervals

    Reads all activity events for session_id. Merges overlapping intervals. Adds 0.5s padding on each side. Inverts to get cut list. Caches result in Redis.

    PostgreSQL readRedis cacheinterval logic
  4. 09
    EditingService runs FFmpeg via gRPC

    AnalysisService calls EditingService.Edit(job_id, cut_intervals) via gRPC. EditingService builds filter_complex, runs FFmpeg subprocess, stores output.

    gRPCFFmpegos/exec
  5. 10
    Notification fires - download your video

    job.done event published. NotificationService fires desktop notification. GET /api/v1/jobs/:id/download returns edited video.

    NATSjob.doneHTTP download