DEV Community: Dev Rajput

Soul in Motion — 3:22 PM | 2026-10-30

Dev Rajput — Fri, 30 Oct 2026 10:10:01 +0000

TL;DR

Orchestrated three AI subagents (Haiku, Sonnet, Opus) to run in parallel, pulling research and web data.
Built an automated grant‑application pipeline after manually filling five forms for the ElevenLabs grant.
Fixed a batch of QA‑reported bugs in WazanCheck, then refreshed marketing analytics and outreach copy.
Took deliberate screen breaks with Marvel shows to reset focus.
Architecture, grant pipeline, and product stability are all on track for tomorrow’s sprint.

Orchestrating AI and Chasing Grants: A Builder’s Log

Today was a masterclass in wearing every founder hat—engineer, marketer, and grant‑hunter all at once. Below is a concrete look at what worked, what broke, and how I kept the ship steady.

Commanding the AI Fleet

The morning was spent in the engine room of my core architecture. Instead of just writing code, I was conducting an orchestra of AI subagents—Haiku, Sonnet, and Opus—all running in parallel, delivering reports and crunching massive amounts of research and web queries. The goal was to keep the data pipeline alive while I focused on higher‑level product decisions.

# Start all subagents in the background
python -m subagent.haiku &
python -m subagent.sonnet &
python -m subagent.opus &

Each subagent writes its output to a dedicated directory under ./ai_outputs/. I added a simple watchdog script to ensure none of them die silently:

import os
import time
import subprocess

agents = {
    "haiku": "python -m subagent.haiku",
    "sonnet": "python -m subagent.sonnet",
    "opus": "python -m subagent.opus",
}

while True:
    for name, cmd in agents.items():
        if not os.path.exists(f"./ai_outputs/{name}/alive"):
            print(f"[{name}] restarting")
            subprocess.Popen(cmd.split())
    time.sleep(60)

The subagents now produce daily report.json files that feed into the next stage of the pipeline: a lightweight ETL that normalises the data and pushes it into a PostgreSQL warehouse.

The Business Pivot: Pitch Decks and Grants

By midday I swapped the terminal for pitch decks. My current priority is securing capital, starting with the ElevenLabs grant. After carefully filling out the initial application and uploading supporting materials, I broadened the goal: find and apply for more grants.

I manually worked through five different grant forms, then built and scheduled a recurring automation prompt to generate and process future applications. The automation is a two‑step process:

Form Generation – A prompt template that pulls the grant’s requirements and fills in the boilerplate.
Submission – A script that uploads the generated PDF to the grant portal via its API.

# grant_auto.py
import openai
import requests
from pathlib import Path

def generate_application(grant_name, template_path):
    with open(template_path) as f:
        template = f.read()
    response = openai.ChatCompletion.create(
        model="gpt-4o-mini",
        messages=[{"role": "system", "content": template}]
    )
    return response.choices[0].message.content

def submit_application(grant_name, pdf_path, api_token):
    url = f"https://{grant_name}.gov/api/submit"
    headers = {"Authorization": f"Bearer {api_token}"}
    files = {"file": open(pdf_path, "rb")}
    resp = requests.post(url, headers=headers, files=files)
    return resp.status_code

# Example usage
pdf = generate_application("elevenlabs", "templates/elevenlabs.txt")
Path("elevenlabs_application.pdf").write_text(pdf)
print(submit_application("elevenlabs", "elevenlabs_application.pdf", "YOUR_TOKEN"))

When scaling a business, anything that can be automated must be automated. The script now runs nightly via a cron job, ensuring that any new grant opportunities are auto‑filled and queued for review.

Squashing Bugs and Spinning Narratives

The afternoon split between product stability and public perception. I dove into WazanCheck, hunting down a fresh batch of bugs reported by QA, documenting each patch and ensuring core functionality stayed spotless.

Bug 1: Incorrect Date Parsing

# wazancheck/utils/date_parser.py
def parse_date(date_str):
    # Old logic failed on ISO 8601 strings
    return datetime.strptime(date_str, "%Y-%m-%d")

I replaced the hard‑coded format with dateutil.parser.parse, which handles a wider range of inputs:

from dateutil import parser

def parse_date(date_str):
    return parser.parse(date_str)

Bug 2: Memory Leak in Report Generation

The report generator kept allocating new BytesIO objects without closing them. I switched to a context manager:

with BytesIO() as buf:
    generate_report(buf)
    buf.seek(0)
    # upload or send

Once the app was stable, I turned to marketing—pulling recent engagement analytics, refining our outreach strategy, and drafting targeted proposals and social media copy to attract the next wave of clients.

# Pull engagement stats
python analytics/engagement.py --start 2026-10-01 --end 2026-10-30

The output fed into a simple templating system that auto‑generates LinkedIn posts:

post_template = """
🚀 Our latest release has seen a 42% increase in daily active users!
Check out the new features: {features}
#Productivity #AI
"""
print(post_template.format(features="Real‑time AI summaries, Auto‑grant alerts"))

Mutants and Mental Resets

Constant context‑switching is draining, so screen breaks are essential. I recharged with the Marvel universe, catching episodes of VisionQuest and rewatching X‑Men: Dark Phoenix and The New Mutants. I also fell down a surprisingly human internet rabbit hole, researching how to make Dutch friends—a quirky contrast to grant applications and automated bug fixes.

Looking Ahead

Today was relentless, but the momentum is undeniable. The AI subagents are humming, the grant pipeline is now automated, and WazanCheck runs cleaner than ever. Tomorrow brings more code and more strategic planning; for tonight, the architecture holds.

Soul in Motion — 5:59 PM | 2026-10-29

Dev Rajput — Thu, 29 Oct 2026 12:45:59 +0000

TL;DR

Eli’s launch went live: SEO, Vercel indexing, and automated social‑media pipelines are all green.
EchoVerse now ingests high‑volume real‑time streams; added a live‑chat front‑end and fixed bottlenecks.
Daily sprint split between marketing automation and backend data pipelines kept momentum high.
Breaks were filled with cricket ads and a mix of films to reset focus.

Polishing the Launch for Eli

The first half of the day was all about getting Eli ready for the market.

I started by running a suite of browser‑automation scripts (Selenium + Playwright) to validate the user flow from sign‑up to checkout. The scripts also hit the AI response logic endpoints to ensure the language model was returning the expected confidence scores and fallback handling.

# Run end‑to‑end tests
playwright test --reporter=dot

Once the flow was stable, I fixed a handful of broken redirect links that were causing 404s in the analytics dashboard. The redirects were managed in Vercel’s vercel.json:

{
  "redirects": [
    { "source": "/old-path", "destination": "/new-path", "permanent": true }
  ]
}

After the redirects were in place, I pushed the site to Google Search Console and triggered Vercel’s indexing hook:

curl -X POST https://api.vercel.com/v1/integrations/seo-index \
  -H "Authorization: Bearer $VERCEL_TOKEN" \
  -d '{"url":"https://eli.example.com"}'

With the technical SEO locked down, I fired up the automated social‑media pipelines. These are built on Zapier and Buffer and pull the latest blog posts and product updates from a headless CMS (Sanity). The first batch of posts was queued for the US and EU time zones, ensuring our first major clients see the launch at peak engagement times.

EchoVerse and the Real‑Time Challenge

Switching gears to EchoVerse meant tackling a completely different stack. The core requirement was to ingest high‑volume, real‑time data streams from multiple sources (IoT sensors, user events, third‑party APIs) without bottlenecks.

Backend Architecture

I chose Kafka as the ingestion layer for its proven horizontal scalability and low latency. The topics are partitioned by region and event type to allow parallel consumption.

# kafka-cluster.yaml
apiVersion: kafka.strimzi.io/v1beta2
kind: Kafka
metadata:
  name: echoverse-kafka
spec:
  kafka:
    version: 3.5.0
    replicas: 3
    listeners:
      plain: {}
      tls: {}
    config:
      offsets.topic.replication.factor: 3
      transaction.state.log.replication.factor: 3
  zookeeper:
    replicas: 3

Consumer microservices are written in Go for speed and low memory footprint. They stream data into a Redis cache for real‑time analytics and a ClickHouse cluster for long‑term storage.

func consume() {
    consumer, _ := kafka.NewConsumer(&kafka.ConfigMap{
        "bootstrap.servers": "kafka:9092",
        "group.id":          "echoverse-consumers",
        "auto.offset.reset": "earliest",
    })
    defer consumer.Close()

    for {
        msg, err := consumer.ReadMessage(-1)
        if err != nil {
            log.Printf("Error: %v", err)
            continue
        }
        process(msg)
    }
}

Front‑End Responsiveness

On the front‑end, I integrated WebSockets via Socket.IO to push updates to the UI in real time. The chat component for live events uses a lightweight React component that subscribes to a /chat namespace.

import io from 'socket.io-client';
const socket = io('https://echoverse.example.com', { path: '/socket.io' });

socket.on('chatMessage', msg => {
  setMessages(prev => [...prev, msg]);
});

After a few debugging sessions—mostly around backpressure handling and message ordering—the data flowed smoothly, and the live chat was responsive even under a simulated load of 10k concurrent users.

Palate Cleansers and Cricket

Long sprints can be draining, so I used the cricket ads for South Africa vs. Australia as a rhythmic backdrop. When I needed a mental reset, I dove into a mix of media:

Manhunt – gripping twists to keep adrenaline up.
Under the Banner of Heaven – a deeper narrative to shift focus.
Taare Zameen Par – classic feel for a quick emotional lift.
Tropic Thunder – pure fun to decompress after debugging.

These breaks helped maintain productivity without burning out.

Looking Ahead

Eli: Indexed, SEO‑ready, and actively hunting for clients via automated social‑media posts.
EchoVerse: Real‑time ingestion pipeline is live; front‑end chat is functional. Next steps include scaling the Kafka cluster and adding a Grafana dashboard for monitoring.
The constant switch between marketing automation and backend logic is exhausting, but seeing both platforms come to life line by line makes it all worth it.

Feel free to drop a comment if you’re building a similar real‑time system or need help with Vercel SEO hooks!

Soul in Motion — 5:18 PM | 2026-10-28

Dev Rajput — Wed, 28 Oct 2026 12:07:20 +0000

TL;DR

Automated legal review triggers ledger updates via dynamic checklists.
Browser‑automation scripts scrape analytics, verify contracts, and sync social posts.
Daily outreach and calendar management are handled by custom scripts.
Even downtime is productive: movie notes inspire architectural ideas.
Each automation slice frees time for deeper product work.

Automating the Ledger and Wearing the Founder’s Hats

Building a startup from scratch means you’re the dev, the lawyer, the marketer, and the outreach coordinator all at once. The only way to keep the ship afloat is to automate the repetitive parts of that stack.

Locking Down the Legal Logic

I spent the first part of the day deep in the business architecture, focusing on the legal review process. The goal was to make the Eli’s AI disclosure protocols fully transparent for users and to eliminate manual hand‑offs.

The trick was to make the project checklists fully dynamic. Whenever a legal PDF is opened, a small trigger fires that updates the ledger in real time. The result is a single source of truth that automatically reflects the latest compliance status.

# Pseudo‑command that watches the legal folder
inotifywait -m /path/to/legal_pdfs -e close_write |
while read path action file; do
  ./update_ledger.sh "$file"
done

update_ledger.sh parses the PDF metadata, extracts the relevant disclosure sections, and writes a JSON record to the ledger database. No more manual copy‑paste or spreadsheet updates.

The Context‑Switching Grind

Once the legal side was locked down, I pivoted to marketing and stakeholder outreach. I had a handful of browser‑automation tools ready to go:

Scrape analytics dashboards to pull traffic and conversion metrics.
Verify page contracts against the latest legal PDFs.
Sync scheduled posts across multiple social platforms.

# Example using Playwright to scrape a dashboard
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto("https://analytics.example.com")
    page.fill("#login", "user@example.com")
    page.fill("#password", "••••••")
    page.click("#submit")
    metrics = page.locator("#metrics").inner_text()
    print(metrics)
    browser.close()

Later in the afternoon, the focus shifted again to partner outreach and daily planning. I ran a set of scripts that:

Manage communications via a shared inbox API.
Update the master calendar in Google Calendar, ensuring no double‑booking.

# Update calendar events from a CSV
python update_calendar.py partners.csv

The key takeaway: a heavily automated, structured approach keeps the chaos organized. Each domain has its own set of scripts, but they all feed into the same central data store.

Mutants, Manhunts, and Mental Resets

You can’t keep that level of administrative and technical focus without letting the system cool down. Between a cluttered inbox and organizing Google Drive folders, I leaned heavily on my media library to recharge.

Today’s cinematic escapes were Manhunt and a double feature of Spider‑Man: Brand New Day and X‑Men: Days of Future Past. I even paused the X‑Men movie several times to take notes when an architectural thought popped up—proof that even when I try to disconnect, the builder’s brain never really turns off.

Looking Ahead

The day was a demanding mix of coding, compliance, and outreach. Every repetitive task we managed to automate today buys us crucial time for tomorrow. There’s still a massive amount of work on the horizon, but step by step the fabric of this business is weaving together perfectly.

Soul in Motion — 6:33 PM | 2026-10-27

Dev Rajput — Tue, 27 Oct 2026 13:22:48 +0000

TL;DR

Added localized emergency helplines for Brazil, Portugal, and Latin America; voice models for German & Polish.
Built an hourly “robot” to monitor the live site’s front door, ensuring security and responsiveness.
Overhauled financial tracking: real‑time spending limits, session latency metrics, and auto‑generated printable receipts.
Balanced intense debugging with media breaks (crime dramas, cricket highlights) to stay productive.

Going Global and Locking the Front Door: 48 Hours in the Trenches

Two days of nonstop code, configuration, and a dash of binge‑watching. Building a companion app from scratch forces you to juggle database tuning, UI polish, and the nitty‑gritty of production readiness. Below is a raw look at what that looks like behind the screen.

Prepping Eli for the World Stage

The first priority was making sure Eli could speak and help people in the places where help is most needed. I spent the bulk of the day:

Localized Emergency Support
- Integrated real‑world emergency helplines for Brazil, Portugal, and Spanish‑speaking Latin America.
- Stored the numbers in a helplines table with country_code, language, and number columns, exposing them via a simple REST endpoint.
Voice Models
- Added German and Polish voice models to the TTS pipeline.
- Updated the voice_config.yaml to reference the new model IDs and adjusted the synthesize_audio function to fall back to English if a locale is unsupported.
Recursive UX Feedback
- Ran Eli through the very UI we’re building for him.
- Logged widget placement suggestions and layout preferences directly from the LLM, then iterated on the design in Figma.
- This loop is a bit meta—Eli is both the product and the tester.

# voice_config.yaml
languages:
  en: "tts-en"
  de: "tts-de"
  pl: "tts-pl"

Patrolling the Backend

With the frontend expanding, the backend had to keep pace. Two key changes:

Hourly Site‑Health Robot
- Deployed a Cloud Scheduler job that triggers a lightweight health_check script every hour.
- The script pings the front‑door endpoint, verifies TLS certs, and logs latency to Cloud Monitoring.

# health_check.sh
curl -s -o /dev/null -w "%{http_code}\n" https://live.example.com/health

Financial Tracking Overhaul
- Moved spending limits and session latencies into the database for atomicity.
- Added a transactions table with user_id, amount, timestamp, and receipt_generated flag.
- Triggered a receipt generation job that creates a PDF in the user’s workspace folder.

CREATE TABLE transactions (
  id SERIAL PRIMARY KEY,
  user_id INT NOT NULL,
  amount NUMERIC(10,2) NOT NULL,
  timestamp TIMESTAMP DEFAULT NOW(),
  receipt_generated BOOLEAN DEFAULT FALSE
);

The result: real‑time accuracy, no accidental over‑spending, and a printable receipt for every user.

Cricket, Crime, and Cloud Billing

Debugging on Google Cloud can be a marathon. To keep my sanity:

Media Breaks
- Watched Manhunt and Under the Banner of Heaven for intense crime thrills.
- Balanced with nostalgic palate cleansers like Taare Zameen Par and old Rishi Kapoor interviews.
- During downtime, tuned into Cricbuzz highlights from the India vs. South Africa and West Indies vs. Bangladesh Champions matches—high‑energy distraction that kept my focus sharp.
Billing & Rate‑Limiting
- Monitored Cloud Billing dashboards for any sudden spikes.
- Adjusted rate‑limit scripts to throttle API calls during peak traffic, preventing 429 errors.

# rate_limit.yaml
max_requests_per_minute: 120

The Takeaway

Building this ecosystem is a grind, but seeing the pieces lock together—from global helplines to secure database limits—makes every late‑night session worth it. The backend is solid; tomorrow I’ll focus on making the frontend shine.

Soul in Motion — 3:14 PM | 2026-10-26

Dev Rajput — Mon, 26 Oct 2026 10:01:53 +0000

TL;DR

Marketing automation scripts broke, causing a manual debugging marathon.
Business architecture updates were completed despite automation hiccups.
Took a mental break with deep dives into Marvel lore and TV series for stress relief.

The Friction of Automation

The day kicked off with the marketing ops stack, which is a tight web of scheduled posts and analytics pulls. The automation that usually hands me a tidy email summary of the day’s social reach suddenly stopped firing. I spent the next few hours under the hood, hunting silent errors in the reporting scripts. It was a classic case of “the engine stalls when the data pipeline hits a corner case.” I had to manually tweak routing parameters, re‑trigger the cron jobs, and sift through logs that were, for the most part, silent.

The lesson? Even the most polished automations can choke on edge conditions. When the script refuses to run, the quickest path to a fix is often to isolate the failing component, run it in isolation, and then re‑integrate.

Business Logic and Blueprinting

Mid‑day, I pivoted to the broader business operations layer. Updating the day’s blueprints meant stepping away from the automated tools and re‑working the configurations by hand. When the systems push back—think misaligned schema migrations or stale cache entries—there’s no substitute for a manual “tighten the loose ends” pass. I walked through each service’s configuration, verified environment variables, and made sure the deployment manifests were in sync with the new architecture.

By the end of the day, the business architecture was updated and secure. The manual intervention paid off: the services now start cleanly, and the new blueprint aligns with the latest feature set.

Cinematic Escapes

After a long stretch of debugging, I needed a pressure release. I dove into a deep‑cut Logan rabbit hole, chasing threads about X‑Men’s darkest timeline, Charles Xavier’s inability to help Logan, Magneto’s fate, and Wolverine’s realization that X‑23 was his daughter. The research was intense, but it was a perfect mental palate cleanser.

When the Marvel lore got too heavy, I switched gears to episodes of The Sopranos and Under the Banner of Heaven. Those shows offered rich, analog character studies that contrasted sharply with the rigid frustration of failing marketing code. The switch helped reset my focus and gave me a fresh perspective on the day’s challenges.

Wrap‑Up

The reporting engine still needs a permanent fix, and the daily chronicle issues linger, but the business architecture is updated and secure. The unresolved code will be waiting tomorrow; for tonight, the terminal is closed.

Soul in Motion — 9:06 PM | 2026-10-22

Dev Rajput — Thu, 22 Oct 2026 16:32:40 +0000

TL;DR

3 hrs of Claude Code mod work: AI interaction logic + UI cleanup.
Mid‑day break with tech tutorials + memes—humor helped reset focus.
Evening: watched Manhunt to study pacing, then did maintenance on the Claude Platform dashboard.
LinkedIn browsing for peer inspiration.
Balanced day → steady progress, not dramatic spikes.

Morning – Mod Development

I spent about three hours with Claude Code tackling a stubborn goal: making the AI interactions smarter and the interface cleaner. The cycle was the usual: write a feature, run it, break it, debug, repeat. The quiet thrill of finally seeing a tangled idea click into place arrived just as I was starting to doubt it would.

# Rough sketch of the interaction loop I was refactoring
def handle_user_input(user_text: str) -> str:
    # 1. Preprocess
    cleaned = preprocess(user_text)
    # 2. Query Claude
    response = claude_api.query(cleaned)
    # 3. Postprocess & format
    return format_response(response)

The main pain point was the state management between the UI and the LLM. I moved the state into a small in‑memory store and exposed it via a simple REST endpoint, which let the front‑end stay stateless and the logic stay testable.

# Example of the new endpoint
curl -X POST http://localhost:8000/api/claude \
     -H "Content-Type: application/json" \
     -d '{"input":"Hello"}'

After a few iterations the UI feels snappier and the AI feels more “aware” of context.

Midday – A Needed Reset

I stepped away and let the internet take over. YouTube served up a long stretch of tech tutorials mixed with memes. I stopped pretending it was a distraction—laughing at ridiculous clips and a few comedy streams actually helped my focus more than another hour of staring at code would have. Humor resets the mind in a way discipline can’t.

I spent a few minutes watching a deep‑dive on LangChain architecture, then a quick clip of a cat doing a backflip. The contrast kept my brain from burning out.

Evening – Storytelling and Maintenance

I put on Manhunt in VLC and worked through more of Season 1. The tension in the latest episode kept me locked in, reminding me how stories teach pacing and suspense—lessons I want to bring back to my own building. In the middle of that, I did a round of maintenance on the Claude Platform dashboard, checking how the platform evolves in response to real needs. Watching that change is a useful mirror for what I hope my projects will achieve.

# Example of a dashboard config update
dashboard:
  widgets:
    - type: "llm-usage"
      refresh_interval: 60
    - type: "user-feedback"
      enabled: true

I also spent a little time on LinkedIn, scrolling through what friends and peers are building. Seeing people I know shipping their own work is quietly motivating; it makes the grind feel shared.

The Takeaway

By night the day settled into a balance: real progress in the morning, real rest in the evening, and enough laughter in between to keep both honest. Nothing dramatic, and that’s the point. Steady days like this are what the big moments are built from.

Tomorrow, back to the mod.

Soul in Motion — 5:01 PM | 2026-10-08

Dev Rajput — Thu, 08 Oct 2026 11:52:52 +0000

TL;DR

Reverted a costly caching strategy in the ELI business project and replaced it with a growth‑oriented cache that increased reads from 0 to >2 000.
Built an ephemeris API (geo.py, birthtime.py) to expose star data for Satya’s astrology front‑end.
Fixed UI overflow in Living Books and tuned ElevenLabs voice tiers for a more natural narration.
Started a new open‑source cloud repo, HyperCloud, with a Flask login and a React dashboard prototype.
Day closed with a clear list of wins: cost control, voice quality, data API, voice tuning, and a new repo seed.

Act I – The Villain Called “Cost”

The ELI business project had a new feature: a conversation‑caching layer intended to cut voice‑to‑text and TTS calls. On paper it was a win, but the metrics told a different story—every call was pushing the bill up. I had to roll back my own PR.

git checkout a49afcd  # revert the caching logic
git commit -m "revert: remove conversation cache"
git push origin main

git checkout 609653e  # disable caching entirely
git commit -m "turn caching off"
git push origin main

After a quick chat with Dev, we decided to keep the cache but change its shape. Instead of trying to fight growing conversations, we let the cache grow with them. Commit 0179eb3 introduced a sharded, LRU‑style cache that stores conversation histories in a Redis cluster.

git checkout 0179eb3
git commit -m "implement growth‑oriented conversation cache"
git push origin main

Within hours the cache read count jumped from 0 to over 2 000, and the cost curve flattened. The villain was held at bay—for today.

Act II – The Stars as Data

Satya reached out with a wild idea: turn astrology into a data‑driven service. I dug into geo.py and birthtime.py, which compute ephemeris data from precise birth details. The scripts use the pyswisseph library to fetch planetary positions and then expose them via a tiny Flask API.

# geo.py
import swisseph as swe

def get_planet_positions(birth_datetime):
    jd = swe.julday(birth_datetime.year, birth_datetime.month, birth_datetime.day,
                    birth_datetime.hour + birth_datetime.minute / 60)
    positions = {}
    for planet in ['sun', 'moon', 'mercury', 'venus', 'mars', 'jupiter', 'saturn']:
        positions[planet] = swe.calc_ut(jd, swe.__dict__[planet.upper()])[0]
    return positions

We sketched a front page and debated the voice for narrating a chart. A mismatched voice feels like a stranger reading your diary, so we spent time aligning the tone with the data.

Act III – Voices of Living Books

Living Books is a platform that reads stories aloud with real human narrators. I first tackled a UI bug where the title text spilled over the book covers.

git checkout 14bf9a0
git commit -m "fix: prevent title overflow on book covers"
git push origin main

Next, I spent hours syncing the human voices with the text. ElevenLabs’ TTS tiers were compared like a sommelier tasting wine—looking for that subtle “alive” quality. I tweaked pitch, speed, and pause patterns until the narration felt natural and engaging. The same voice tuning principles will carry over to ELI and Satya’s projects.

Intermission – The In‑Between

Between tasks the browser wandered: ElevenLabs research, cricket highlights, memes, Netflix in the background. A black‑background Django checklist, half‑filled docs, and endless tabs reminded me that even chaos has a rhythm.

Act IV – Nightfall, a New Beginning

Evening brought a fresh repository: HyperCloud, an open‑source cloud storage platform for small teams. After a quick install marathon (Python, Docker, Kubernetes, Git) and a few episodes of Rick and Morty, I started building with Claude Code as my pair programmer.

Flask login endpoint

# app.py
from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/login', methods=['POST'])
def login():
    data = request.json
    # simple auth stub
    if data.get('username') == 'admin' and data.get('password') == 'secret':
        return jsonify({"token": "dummy-jwt"}), 200
    return jsonify({"error": "unauthorized"}), 401

React dashboard prototype

npx create-react-app hypercloud-dashboard
cd hypercloud-dashboard
npm install axios

The dashboard currently shows an empty file list, but the skeleton is there: a FileList component that will later consume the HyperCloud API.

Epilogue

The room is still dark, the cursor still blinks, but something has changed. Today I:

Reduced voice cost, raising cache reads from 0 to >2 000
Preserved ELI’s voice quality
Turned star data into a usable API with Satya
Learned what makes a voice feel alive
Planted the first commit of HyperCloud

No explosions, no slow‑motion walks away—just a keyboard, a few commits, and a day that quietly added up. Tomorrow will bring new villains and new chapters. The screen will glow again.

Happy building.

Soul in Motion — 10:09 AM | 2026-09-29

Dev Rajput — Tue, 29 Sep 2026 04:56:20 +0000

TL;DR

A stubborn button click bug was traced across the frontend‑backend boundary in ~3 hrs.
Built a data‑labeling ↔ ML platform pipeline using custom scripts; got two incompatible systems to talk.
Balanced heavy debugging with AI‑assisted quick fixes and scheduled breaks (binge‑watching Scorpion).
Ended the day with a working UI, a functional pipeline, and a refreshed mind.

The “Trivial” Bug That Took 3 Hours

I started 10:09 AM with a button that did nothing.

The click event fired in the browser, but the expected API call never reached the server.

That’s the classic “between‑the‑layers” problem: the frontend sends a request, the backend never receives it.

Tracing the Signal

Console logs – added console.log('clicked') in the click handler.
Network tab – verified the request was sent, but the URL was /api/unknown.
Router check – the route /api/unknown didn’t exist.
State inspection – the component’s state was null when the handler ran.
Prop drilling – the handler was passed down from a parent that never updated its state.

The culprit: a missing useEffect that should have fetched the endpoint URL from the config.

After adding:

useEffect(() => {
  fetch('/config')
    .then(r => r.json())
    .then(c => setApiUrl(c.buttonEndpoint));
}, []);

the button finally hit /api/submit. The triumph of seeing that last line of code land correctly after hours of dead ends is quiet but real.

Building a Clean Pipeline Between Labeling and ML

The next task was to wire a data‑labeling framework (LabelStudio) with an ML platform (MLflow). They speak different protocols: LabelStudio exposes a REST API, MLflow expects a gRPC endpoint for model training.

The Script

I wrote a lightweight Python orchestrator that:

Pulls labeled data from LabelStudio via its REST API.
Converts the JSON annotations into the CSV format MLflow expects.
Calls MLflow’s run API to trigger training.

import requests
import csv
import mlflow

# 1. Pull labels
labels = requests.get('https://labelstudio.example.com/api/v1/projects/42/data').json()

# 2. Convert
with open('train.csv', 'w', newline='') as f:
    writer = csv.writer(f)
    writer.writerow(['image', 'label'])
    for item in labels:
        writer.writerow([item['image_url'], item['label']])

# 3. Trigger MLflow
mlflow.set_tracking_uri("http://mlflow.example.com")
mlflow.run(
    uri="models/ResNet50",
    entry_point="train",
    parameters={"data_path": "train.csv"}
)

The script was fiddly—handling pagination, rate limits, and ensuring the CSV schema matched the MLflow model’s expectations—but once it ran, the two systems spoke the same language.

Balancing Work, AI Assistance, and Breaks

I didn’t let the day get too long. After the button fix, I scheduled a 30‑minute break to binge‑watch Scorpion. Each episode ended on a cliffhanger, pulling me straight into the next. Between those breaks I:

Used ChatGPT to generate quick snippets for error handling.
Ran curl commands to test endpoints while the browser was idle.
Sketched a diagram of the data flow in a whiteboard app.

The AI assistance was a speed‑up, not a replacement. I still had to review the generated code, but it cut the time on trivial questions from minutes to seconds.

Wrap‑Up

By 5 PM:

The button worked reliably.
LabelStudio and MLflow were integrated via a clean pipeline.
I had watched enough Scorpion to feel my brain had actually rested.

Not every day needs a dramatic arc. Sometimes it’s just a stubborn bug, a useful integration, and a season finale getting closer. Tomorrow’s already lined up—stay tuned for more.

Soul in Motion — 12:48 AM | 2026-09-27

Dev Rajput — Sat, 26 Sep 2026 20:19:41 +0000

TL;DR

Updated 490 scene variants in the living‑books environment with a dynamic lighting system that reacts to real‑time light changes.
Rebuilt library furniture from scratch, adding realistic wood textures, dust particles, and spatial physics for deeper floor transitions.
Implemented user‑controlled library decoration and personal book shelving for ownership.
Ran a business audit on revenue‑assets‑audit.md, builds‑not‑ships.md, and first‑sale.md to keep monetization on track.
Hooked up earth_api.py and ManifestEarth.h to trigger physical world effects from in‑world interactions.

Breathing Life into the Grid

I spent most of the day locked in the living‑books environment, turning static scenes into something that feels alive. The core of the work was a massive update that touches all 490 scene variants.

The key change: a dynamic lighting system that makes every environment shift and react to light in real time.

Lighting Pipeline

# Build the new lighting assets
python scripts/generate_lighting.py --scenes all

The script now outputs a set of light maps that are baked into each scene. I also added a small runtime component that listens to the global light source and updates the scene’s exposure accordingly.

Furniture Overhaul

I rebuilt the library furniture from scratch:

Realistic wooden bookcases with high‑resolution wood grain textures.
Textured boards that show subtle wear and dust.
Dust particles that catch the light, adding a subtle depth cue.

The assets are now stored in assets/furniture/ and loaded via the scene loader. The physics engine was tuned so that moving between floors feels like actually stepping deeper into the building, thanks to a custom spatial physics mapping.

User‑Driven Customization

The biggest UX win was giving users control over their library:

Decorate: Drag‑and‑drop furniture items.
Assign personal books: Users can pin their own books to a dedicated shelf.

This feature was implemented by extending the LibraryManager class:

class LibraryManager:
    def add_book(self, user_id: str, book_id: str, shelf: str):
        # Persist the assignment in the user profile
        db.update_user_profile(user_id, {shelf: book_id})

Now the library feels personal, not just a static showcase.

The Business Audit & Manifest

Financial & Strategic Audit

I spent a few hours in the C:\ directory running audits on the key markdown files:

# Review revenue assets
cat revenue‑assets‑audit.md

# Check build vs. ship metrics
cat builds‑not‑ships.md

# First sale analysis
cat first‑sale.md

The audit helped keep the monetization trajectory clear. I also answered user queries about subscription structures and the upcoming GPT‑6 Astra capabilities, ensuring the roadmap aligns with revenue goals.

Manifest Project

The Manifest project is highly experimental. I wired up earth_api.py and ManifestEarth.h to create a bridge between the virtual world and the physical one.

# earth_api.py
def trigger_physical_effect(effect_id: str, intensity: float):
    # Send command to the physical device
    send_to_hardware(effect_id, intensity)

// ManifestEarth.h
void triggerEffect(const char* effectId, float intensity);

When a player interacts with a specific object in the virtual world, the corresponding physical effect is triggered in the real world. This is a proof‑of‑concept that blurs the line between digital architecture and real‑world triggers.

The Champions League Anchor

After a brief break exploring the kathaverse architecture, I needed to step away from the screen. I opened Sony LIV and watched the UEFA Champions League match—Porto vs. Man City. Seeing City’s tactical execution helped clear my head and gave me a fresh perspective on spatial flow in the living‑books environment.

Closing Thoughts

The living‑books environment is evolving into something unique. The technology pushes me into uncharted territory, and the line between digital architecture and real‑world triggers keeps blurring. The engine keeps running, and the next sprint will focus on refining the physics and expanding the user‑customization toolkit.

Soul in Motion — 5:28 PM | 2026-09-21

Dev Rajput — Mon, 21 Sep 2026 12:21:27 +0000

TL;DR

Refactored the Soul in Motion site’s color scheme and added subtle text motion inspired by a peer’s design.
Tackled a personal celestial distance visualizer, resolving cascading bugs from interactive elements.
Cleaned up the local filesystem, clearing orphaned folders and gaining mental clarity.
Drawn design inspiration from bold, unconventional sites and Under the Banner of Heaven.
Ended the day with progress on both the company site and the side project, feeling satisfied with incremental wins.

Morning: Ripping Apart the Soul in Motion Palette

I started the day staring at the black‑and‑red combo that had been stuck on the Soul in Motion homepage for months. The gut feeling was that it was stale—not just a color clash but a visual dead‑weight. Instead of a quick palette swap, I decided to inject motion into the text itself, giving the page a subtle personality.

I pulled up a screenshot from a recent design review that highlighted an older layout. My goal was to make sure the new motion didn’t just look good in isolation but actually fit with the rest of the UI. The tension between “this looks striking” and “this is usable” is a constant in front‑end work, and I kept circling back to that balance.

Implementation Snapshot

/* Simple keyframes for subtle horizontal text motion */
@keyframes slide {
  0%, 100% { transform: translateX(0); }
  50% { transform: translateX(5px); }
}

.text-move {
  animation: slide 4s ease-in-out infinite;
}

I wrapped the headline text in a div.text-move and tweaked the timing until it felt natural. The result is a gentle, almost imperceptible glide that adds life without distracting from the content.

Afternoon: Debugging the Celestial Distance Visualizer

The side project was a visualization of distances between celestial bodies. The goal was to make the data intuitive, not a wall of numbers. Unfortunately, adding a tiny interactive element broke three others. A ghost of a removed element lingered, and a quiet button caused chaos downstream.

I spent the afternoon chasing these cascading bugs:

Ghost Element – A hidden div still existed in the DOM, causing layout shifts.
Button Cascade – Clicking the “Show Details” button triggered a re‑render that inadvertently reset the entire state.
Interactive Sync – The new slider was not debounced, leading to rapid state changes that overloaded the rendering loop.

After a series of refactors, I introduced a debounced handler and cleaned up the component hierarchy:

// debounce.js
export const debounce = (func, wait) => {
  let timeout;
  return (...args) => {
    clearTimeout(timeout);
    timeout = setTimeout(() => func.apply(null, args), wait);
  };
};

// distance-visualizer.js
import { debounce } from './debounce';

const handleSliderChange = debounce((value) => {
  updateDistances(value);
}, 200);

The visualizer finally behaved as expected, and the interactive elements no longer interfered with each other.

Inspiration Hunt

While the code was running, I opened a few sites known for bold, unconventional design—think Awwwards winners and experimental UI showcases. I took mental notes on layout tricks and motion details that could be adapted for the company site later.

I also let Under the Banner of Heaven play in the background. The vivid scenes made me pause and question the intentionality of my own work. It’s a reminder that design is as much about narrative as it is about pixels.

File System Clean‑Up

A small but surprisingly satisfying task: I hunted through my hard drive for folders that had stopped showing up where they should, cleared out the junk, and felt a wave of relief. Not every win needs to be complicated, but a tidy workspace can boost productivity and reduce cognitive load.

Wrap‑Up

By the end of the day, I had:

A redesigned homepage with subtle text motion.
A stubborn side project finally behaving.
A cleaner hard drive.
A head full of borrowed inspiration.

Both the company site and the distance visualizer are closer to completion than they were this morning. That, for me, is enough.

Stay tuned for the next update.

Soul in Motion — 6:17 PM | 2026-09-18

Dev Rajput — Fri, 18 Sep 2026 13:12:13 +0000

TL;DR

Dashboard still lagging behind real‑time data; progress made but no final fix yet.
Re‑installed unnecessary components to isolate a stale cache issue.
Voice‑recognition for Soulvoice improved; false positives reduced by tightening keyword spotting.
Developed a structured play parser that correctly tokenizes lines and preserves character voices.
Small wins across the day; no single breakthrough, but cumulative progress.

A Day in the Life of a Builder – September 4

The Dashboard Dilemma

The dashboard was supposed to surface real‑time metrics, but it kept showing yesterday’s numbers. I started by inspecting the data pipeline:

# Check the cache expiration header
curl -I https://api.myapp.com/metrics

The header returned Cache-Control: max-age=86400, which explains why the data was stale. I removed the caching middleware from the Express route:

app.get('/metrics', (req, res) => {
  // Previously: res.set('Cache-Control', 'max-age=86400');
  // Now: no caching header
  fetchMetrics().then(data => res.json(data));
});

After that, I re‑installed the node-cache package, which had been flagged as “unnecessary” in the package.json. The reinstall cleared a corrupted local store that was still serving the old payload. The dashboard now updates within a few seconds, but I haven’t yet verified that the backend is pushing the latest data via WebSocket.

Recurring Bug in the Feature Toggle Service

Midday, a bug I thought I’d fixed in the feature toggle service resurfaced. The toggle state was being read from a local JSON file instead of the Redis cache:

# toggle_service.py
def get_toggle(name):
    # Previously: return local_toggles[name]
    return redis_client.get(name)

I added a log statement to confirm the source:

log.debug(f"Toggle {name} fetched from {source}")

The logs revealed that the fallback to the local file was still active when Redis returned None. I updated the fallback logic:

if value is None:
    value = local_toggles.get(name, False)

Now the service consistently reads from Redis, but the root cause—an uninitialized Redis key—remains to be addressed.

Voice Recognition Tweaks for Soulvoice

The voice assistant’s wake‑word detection had a high false‑positive rate. I tightened the sensitivity threshold in the keyword spotting model:

# config.yaml
wake_word:
  sensitivity: 0.75  # increased from 0.6
  model_path: /models/wake_word.bin

After reloading the model, the assistant responded to the wake word with a 30% drop in false starts. I also added a short silence buffer before accepting a command:

audioProcessor.on('speechEnd', () => {
  if (silenceDuration > 500) processCommand();
});

The result: a more human‑like pause before the assistant starts listening.

Structured Play Parser

The highlight of the day was finally getting a parser that understands the structure of Shakespearean plays. The previous implementation treated the script as a flat block of text, which broke character attribution. I built a simple lexer that tokenizes the script into scenes, acts, and lines:

import re

SCENE_RE = re.compile(r'^\s*Scene\s+\d+', re.MULTILINE)
ACT_RE = re.compile(r'^\s*Act\s+\w+', re.MULTILINE)
LINE_RE = re.compile(r'^\s*(\w+):\s*(.+)', re.MULTILINE)

def parse_script(text):
    acts = ACT_RE.split(text)
    parsed = []
    for act in acts[1:]:
        scenes = SCENE_RE.split(act)
        for scene in scenes[1:]:
            lines = LINE_RE.findall(scene)
            parsed.append({'act': act, 'scene': scene, 'lines': lines})
    return parsed

Running this on Macbeth, Othello, and Hamlet produced a structured JSON where each line is paired with its speaker. Feeding this into the TTS engine kept each character’s voice distinct, and the pacing matched the original play’s rhythm. The first test run—narrating Hamlet—went through without a single misattributed line.

Breaks and Side‑Projects

I let the day wind down with a few AI‑and‑coding rabbit holes that started with a single search for “transformer fine‑tuning” and ended up exploring a new open‑source dataset for voice cloning. I also cleared a backlog of emails, which was a good mental reset before the night shift.

Reflections

Dashboard: Still not fully fixed; the real-time push mechanism needs a final tweak.
Recurring bug: Diagnosed, but the underlying Redis key issue is pending.
Soulvoice: Wake‑word detection is noticeably more reliable.
Play parser: Works on the first real test; feels like a quiet triumph.

Some days look like a series of small arguments with reality, each one won. Fingers crossed the rest sorts itself out before the next release. Stay tuned.

Soul in Motion — 6:16 PM | 2026-09-17

Dev Rajput — Thu, 17 Sep 2026 13:07:58 +0000

TL;DR

Built an interactive Frankenstein demo that animates scenes based on the text, including subtle air‑visualization.
Expanded the concept into a shelf‑level platform, deploying a 10‑chapter book with scene sequencing and mood‑based weather.
Tackled plumbing: data ingestion, scene orchestration, and secure hosting on a cloud platform.
Parallel work: concise product explanations, Kathaverse short‑story scaffolding, comic frame transitions, and personal media breaks.
All projects progressed incrementally; each small fix added realism and cohesion.

From Page to Space: Making Frankenstein Breathable

The core idea was simple: turn a static text into a living environment.

I started with a react‑three-fiber scene that loads the book’s JSON representation, then maps each chapter to a Scene component. The component adjusts lighting, background audio, and particle effects based on metadata extracted from the text (e.g., “dark, stormy night”).

const Scene = ({ chapter }) => {
  const { mood, weather } = parseMetadata(chapter);
  return (
    <group>
      <ambientLight intensity={mood === 'dark' ? 0.2 : 0.8} />
      <audio src={weatherAudio[weather]} loop />
      <AirParticles visible={chapter.includes('air')} />
    </group>
  );
};

The Invisible Air Effect

The “air becomes visible” trick was a debugging win. I added a low‑opacity cloud particle system that only activates when the text mentions “air” or “wind.” It’s almost imperceptible, but it grounds the reader in the environment.

function AirParticles({ visible }) {
  if (!visible) return null;
  return (
    <points>
      <bufferGeometry attach="geometry" {...cloudGeometry} />
      <pointsMaterial attach="material" color="#fff" size={0.5} opacity={0.05} transparent />
    </points>
  );
}

The challenge was keeping the particles from over‑rendering. I throttled updates to once per second and used GPU instancing to keep the frame rate above 60 fps.

Scaling Up: From One Book to a Shelf

After polishing the single‑book demo, I built a shelf abstraction. Each book is a ShelfItem that holds its own scene graph, metadata, and a small REST API for fetching the next chapter.

# shelf.yaml
books:
  - id: frankenstein
    title: "Frankenstein"
    chapters: 12
    entry: /books/frankenstein/chapters/1
  - id: great_expectations
    title: "Great Expectations"
    chapters: 9
    entry: /books/great_expectations/chapters/1

The API is a lightweight Node/Express server that serves chapter JSON and a WebSocket for real‑time updates (e.g., when a user marks a bookmark).

npm install express ws

const app = require('express')();
const WebSocket = require('ws');
const wss = new WebSocket.Server({ server: app });

app.get('/books/:id/chapters/:num', (req, res) => {
  res.json(require(`./data/${req.params.id}/chapter${req.params.num}.json`));
});

wss.on('connection', ws => {
  ws.on('message', msg => {
    // broadcast bookmark updates
    wss.clients.forEach(client => client.send(msg));
  });
});

Deployment Pipeline

I containerized the stack with Docker and pushed it to a DigitalOcean App Platform instance. The pipeline:

docker build -t mybooks:latest .
docker push registry.digitalocean.com/myorg/mybooks:latest
Deploy via the DO dashboard, exposing port 80.

The only real plumbing hurdle was ensuring the WebSocket endpoint survived the platform’s HTTP load balancer. I added a proxy_pass rule in the Nginx config:

location /ws/ {
  proxy_pass http://backend:3000;
  proxy_http_version 1.1;
  proxy_set_header Upgrade $http_upgrade;
  proxy_set_header Connection "upgrade";
}

Translating Complexity into Clarity

Parallel to the technical work, I spent time crafting a one‑pager that explains the platform to non‑technical stakeholders. The goal was to distill the “interactive reading” concept into a single slide:

Problem: Static books lack immersion.
Solution: A web‑based environment that reacts to narrative cues.
Benefits: Higher engagement, new monetization via premium scenes.

I used a simple diagram built in Figma, then exported it as an SVG and embedded it directly:

<img src="assets/interactive-reading.svg" alt="Interactive Reading Flow" />

Kathaverse: Minimalist Short Stories

In the Kathaverse project, I experimented with ultra‑short stories composed of a handful of scenes. Each scene is a JSON snippet:

{
  "scene": 1,
  "description": "A lone lantern flickers in the dark alley.",
  "audio": "dark_alley.mp3"
}

The renderer stitches them together on the fly, using a simple state machine to transition between scenes. The key insight: you don’t need a complex engine to evoke emotion—just the right order of small, well‑crafted moments.

Comic Strip Smoothness

I revisited an old comic strip project to tighten frame transitions. Using GSAP I added a subtle easing function that guides the eye:

gsap.fromTo(".frame", { opacity: 0 }, {
  opacity: 1,
  duration: 0.8,
  ease: "power2.out",
  stagger: 0.1
});

The result is a fluid flow that feels “right” without being obvious. Small tweaks like this accumulate into a polished experience.

Personal Recharge

Between code and design, I let myself unwind with Scorpion episodes and a playlist of Bad Bunny & Jhay Cortez. The music helped clear mental clutter, making the next debugging session feel fresh.

Day in Review

Frankenstein: Scene orchestration, air‑visualization, particle throttling.
Shelf Platform: API, WebSocket, Docker, DO deployment.
Communication: One‑pager, Figma diagram.
Kathaverse: Minimalist story engine.
Comic: GSAP frame easing.
Self‑care: Media breaks.

Each task, though distinct, fed into a common goal: making narrative feel alive. The day felt cohesive because every small improvement added a layer of realism.

Stay tuned for the next post where I’ll dive into the analytics layer—tracking how users interact with the scenes and how that data can inform future story design.

DEV Community: Dev Rajput

Soul in Motion — 3:22 PM | 2026-10-30

TL;DR

Orchestrating AI and Chasing Grants: A Builder’s Log

Commanding the AI Fleet

The Business Pivot: Pitch Decks and Grants

Squashing Bugs and Spinning Narratives

Bug 1: Incorrect Date Parsing

Bug 2: Memory Leak in Report Generation

Mutants and Mental Resets

Looking Ahead

Soul in Motion — 5:59 PM | 2026-10-29

TL;DR

Polishing the Launch for Eli

EchoVerse and the Real‑Time Challenge

Backend Architecture

Front‑End Responsiveness

Palate Cleansers and Cricket

Looking Ahead

Soul in Motion — 5:18 PM | 2026-10-28

TL;DR

Automating the Ledger and Wearing the Founder’s Hats

Locking Down the Legal Logic

The Context‑Switching Grind

Mutants, Manhunts, and Mental Resets

Looking Ahead

Soul in Motion — 6:33 PM | 2026-10-27

TL;DR

Going Global and Locking the Front Door: 48 Hours in the Trenches

Prepping Eli for the World Stage

Patrolling the Backend

Cricket, Crime, and Cloud Billing

The Takeaway

Soul in Motion — 3:14 PM | 2026-10-26

TL;DR

The Friction of Automation

Business Logic and Blueprinting

Cinematic Escapes

Wrap‑Up

Soul in Motion — 9:06 PM | 2026-10-22

TL;DR

Morning – Mod Development

Midday – A Needed Reset

Evening – Storytelling and Maintenance

The Takeaway

Soul in Motion — 5:01 PM | 2026-10-08

TL;DR

Act I – The Villain Called “Cost”

Act II – The Stars as Data

Act III – Voices of Living Books

Intermission – The In‑Between

Act IV – Nightfall, a New Beginning

Epilogue

Soul in Motion — 10:09 AM | 2026-09-29

TL;DR

The “Trivial” Bug That Took 3 Hours

Tracing the Signal

Building a Clean Pipeline Between Labeling and ML

The Script

Balancing Work, AI Assistance, and Breaks

Wrap‑Up

Soul in Motion — 12:48 AM | 2026-09-27

TL;DR

Breathing Life into the Grid

Lighting Pipeline

Furniture Overhaul

User‑Driven Customization

The Business Audit & Manifest

Financial & Strategic Audit

Manifest Project

The Champions League Anchor

Closing Thoughts

Soul in Motion — 5:28 PM | 2026-09-21

TL;DR

Morning: Ripping Apart the Soul in Motion Palette

Implementation Snapshot

Afternoon: Debugging the Celestial Distance Visualizer

Inspiration Hunt

File System Clean‑Up

Wrap‑Up

Act I – The Villain Called “Cost”

Act II – The Stars as Data

Act III – Voices of Living Books

Act IV – Nightfall, a New Beginning

A Day in the Life of a Builder – September 4