标签：#buildinpublic

Building voice AI sounds deceptively clean on paper: capture speech, stream it to an STT engine, prompt an LLM, and synthesize audio back in real time. In reality, building a real-time, multilingual voice assistant that handles high-stress banking fraud while running on desktop hardware in 30°C heat with unstable power is a completely different story. As a Class 12 student diving into my first-ever hackathon, I spent the last 10 days of the #VoiceForBharat Challenge building Raksha —an empathetic, multi-agent voice assistant designed to protect Indian citizens from cyber scams, verify official government schemes, and escalate active financial fraud to human coordinators. Here is the honest breakdown of how Raksha evolved from Day 1 to Day 10, the absurd hurdles along the way, and what it actually takes to build reliable voice systems. 1. The Core Problem: Panic & Digital Banking Scams India's digital payments ecosystem is scaling at lightspeed, but so is financial fraud. Every day, people receive panic-inducing SMS messages claiming: "Your bank account is blocked. Update KYC immediately or share OTP." When someone is panicked, reading a 5-page PDF advisory is the last thing they will do. They need immediate, reassuring spoken advice in accessible Hinglish: "Ghabraiye mat. Bank kabhi phone ya message par OTP nahi mangta. Yeh poori tarah fraud hai." Voice is the most natural medium for this. If an AI agent can step in during those critical first 60 seconds, it can prevent immediate financial loss. 2. The 10-Day Journey: Power Cuts, Audio Hacks & Architecture Days 1–3: The Rocky Start & The Audio Hack Day 1 was pure chaos. I was battling 404s and gRPC hanging issues while connecting Gemini and LiveKit. Exactly 16 minutes before the midnight deadline, the power cut out completely. When it returned a minute past midnight, my desktop greeted me with a blue SrtTrail.txt Windows repair screen—and then another storm knocked the grid out again. I thought I was out on Day 1, b

For the last 10 days, I have been building a voice agent called Shiksha as part of the 10 Days of Voice Agents — VoiceForBharat Edition challenge by Murf AI. My original idea was simple: Build a voice agent that can help students learn through natural conversation. Over the challenge, that idea grew into a complete voice-based learning system with memory, tools, human escalation, call analytics, and a specialist agent . What is Shiksha? Shiksha is a voice-based learning partner for students. Instead of typing questions and reading answers, a student can simply talk to Shiksha. A student can: Ask learning questions Take quizzes Continue learning with their saved profile Get help when they are stuck Practice mathematics Get transferred to a Maths Specialist when needed The main goal was to make the experience feel more like a conversation than a traditional chatbot. Tech Stack Component Technology Real-time voice LiveKit Speech-to-Text Deepgram LLM Gemini Text-to-Speech Murf Falcon Backend Python Memory SQLite Call analytics Flask + SQLite External data Open Trivia Database The voice experience is powered by Murf Falcon , which was one of the main parts of the challenge. How Shiksha Works At a high level, the system looks like this: STUDENT │ ▼ LiveKit Real-time Audio │ ▼ Deepgram Speech-to-Text │ ▼ Gemini Agent Reasoning │ ┌────────────┼─────────────┐ │ │ │ ▼ ▼ ▼ Memory Tools Handoff SQLite Quiz API Maths Specialist │ │ │ └────────────┴─────────────┘ │ ▼ Murf Falcon Text-to-Speech │ ▼ STUDENT This was the basic architecture that I built and expanded throughout the challenge. What I Built 1. Student Memory One of the first things I added was a simple memory system using SQLite. Shiksha can store: Student name Current learning level Topics covered Last interaction This means the agent can use information from previous conversations instead of starting from zero every time. 2. Real Tool Calling For quizzes, I didn't want the agent to always generate questions from memor

For the past few months, I've been working on a project that translates online meetings in real time. At first, I thought the problem would mostly be about choosing the right speech recognition model and finding a good translation API. It turned out those were the easy parts. The real challenge was making everything feel instant. People don't wait for subtitles. If the translation appears two or three seconds after someone finishes speaking, the conversation has already moved on. Technically it works, but from a user's perspective, it feels broken. That completely changed how I approached the project. Instead of optimizing only for accuracy, I had to optimize the entire pipeline for latency: Capturing audio continuously Streaming audio to ASR Performing speech recognition incrementally Translating partial sentences Updating subtitles without flickering Handling corrections when the speech recognizer revised previous words Every stage might only take a few hundred milliseconds, but together they determine whether the experience feels "real-time." Another lesson surprised me even more. Translation quality isn't just about picking a better LLM. Spoken language is messy. People interrupt each other, change direction halfway through a sentence, use filler words, and rarely speak in complete grammatical sentences. A model that performs well on benchmarks can still struggle in a live conversation if the input arrives one fragment at a time. That forced me to rethink prompts, buffering strategies, and when to display or revise translated text. Building this project also gave me a new appreciation for streaming systems in general. Real-time applications are fundamentally different from batch processing. Instead of asking, "How accurate is the result?", you're constantly balancing three competing goals: Latency Stability Accuracy Improving one often makes another worse. I'm still learning every day, and there are plenty of problems left to solve. Over the next few weeks, I'd

How long does it take to publish one article? If you run a one-person company, the honest answer isn't "the few hours of writing." It's everything that comes after — moving it into your newsletter, copying it to one dev community, pasting it into another, translating it for an English audience, cutting a short version for X, dropping a note somewhere else. That relay of copy-paste-reformat costs more energy than the writing itself. This week I killed that chore. Now I finish a draft, drop it into a single spreadsheet, run one command, and it fans out to eight platforms on its own. But I don't want to talk about "I built an automation tool." That's the small part. I want to talk about three judgments that are worth far more: where a solo founder's real bottleneck lives, how this machine should actually be built — and how it nearly lied to me. Writing isn't the bottleneck. Distribution is. Most people assume the hardest thing about a one-person company is content output. It isn't. AI has already crushed the marginal cost of writing to the floor. What actually eats your time is the repetitive labor of pushing the same piece across a dozen platforms: log in, paste, fix formatting, upload the cover, edit the tags, publish, log it. Five minutes per platform, eight platforms, forty minutes — every single day. This labor has one especially miserable property: it creates no new value. It's pure hauling of things that already exist from one place to another. And yet you can't skip it — no distribution means even great writing goes unread. So when you work alone, the first thing to industrialize isn't "write faster." It's "hand the entire distribution chore — the certain, repetitive, judgment-free part — over to the machine." A central dispatcher plus plug-in channels I didn't build one giant "fully automatic publisher" for this. Those look great in a demo, but they're a nightmare to change — adding a single platform means touching the whole flow. Instead I split it into two l

There are two ways to work with an AI agent and I had tried both. Write the thing yourself and hand over only the tedious parts. Or hand over the whole task and audit whatever comes back at the end. The first is slow. The second is fast right up until it is wrong, and by then the wrong thing is finished. I expected this series to be about forcing a third option into existence. Nine parts of making an agent follow a workflow it would rather skip. That is not what happened. I never had to enforce it once. The queue that started this had a payload contract nobody had verified, and each phase after that cost me something before it gave anything back. A plan that would not move until the risk register named the provider contract the brief had only guessed at. A build that missed nothing except what my own brief left out. A review that stopped handing back a feeling and started handing back a verdict on every requirement I had already called done. A matrix instead of a trusted green run. A rollback with a name on it before anything got called shipped. And a retrospective that would not let a lesson through until it had checked itself against the trail. Eight parts of that. What I did not expect was which part turned out to be automatic. The Fight I Expected Never Started By the time I finish writing a requirement, I already know roughly what it is going to cost. Most engineers do. You can feel the difference between a one-line fix and something that is going to touch four files and a migration before you have written a single line of it. What I assumed was that the agent could not feel that, and that policing the gap would be my job forever. Reminding it to run the chain. Catching it when it decided a spike was small enough to skip. It has not needed the reminder. Small bugs do not trigger a brief and a plan, and they should not. A standard requirement, a spike, anything long or cross-cutting, runs the full cycle in order. The classification lands where I would have put i

Adding a “Control de Obra” Module to Ventas → Desarrollos (NestJS + Next.js) TL;DR: I built a brand‑new Construction feature (Control de Obra) inside the Ventas → Desarrollos flow, wiring a NestJS controller, a migration for branding_settings , and a Next.js page. While doing that I also fixed the setToken bug that stopped the BrokerDashboard from refreshing its session. The result is a clean, testable API endpoint and a functional UI component that talks to it. The Problem Our product needed a way for sales teams to track the construction status of each development (obra). The UI already had a “Desarrollos” list, but the backend had no endpoint to create, read, update, or delete construction records. At the same time the BrokerDashboard ( apps/web/src/app/portal-broker/page.tsx ) was failing to refresh the user session after a token rotation. The console showed: Error: setToken is not a function at Object.<anonymous> (src/portal-broker/page.tsx:78:15) Both issues were blockers: No API → the UI could only display static data. Stale token handling → users were logged out unexpectedly after a token refresh. What I Tried First I first tried to reuse the existing VentasPropertiesController ( apps/api/src/ventas/ventas-properties.controller.ts ). The controller was already imported in AppModule , but it was dead code (the class had no routes) and its methods lacked the AuthGuard we use across the API. I added a couple of ad‑hoc routes inside that controller, but: The routes conflicted with the existing /ventas namespace. The controller’s @UseGuards(AuthGuard) was missing, causing 401 errors in the browser. The migration for branding_settings was still out of sync, leading to a “column does not exist” error when the new endpoint tried to read branding data. After a few hours of chasing 404s and 401s, I decided the cleanest path was to create a dedicated module for construction and keep migrations in sync. The Implementation 1. Register the new controller in AppModule // a

Automating Multi‑Platform Content Publishing with a Node.js Scheduler TL;DR: I extended the content-automation repo to generate weekly newsletters, Dev.to articles, and platform‑specific markdown in a single CI run. The key was a tiny Node.js scheduler that reads a JSON manifest, writes files, and flips “generated” flags in metadata.json so downstream pipelines know what to publish. The Problem Our content pipeline had three independent manual steps: Write a weekly newsletter markdown file. Draft a Medium article. Publish a Dev.to post. Each step required copying the same body copy into a different folder ( weekly/ , content-automation/medium_* , content-automation/substack_* ) and then manually toggling flags in metadata.json . During a production run on 2026‑08‑08 the CI job failed with a cryptic log line: Error: Conn The truncated message was coming from the Prisma client that our automation script uses to fetch the latest draft from the CMS. Because the script never updated the metadata.json flags after a successful write, the next run tried to re‑process the same draft, hit a stale DB connection, and blew up. In short: the automation was not idempotent , and the state tracking was brittle. What I Tried First My first attempt was to wrap the whole generation flow in a try / catch and, on any error, abort the job without touching the manifest. I added a quick if (fs.existsSync(filePath)) return; guard to each write operation. // naive guard if ( fs . existsSync ( targetPath )) { console . log ( ` ${ targetPath } already exists – skipping` ); return ; } That prevented duplicate files, but it also silently skipped a legitimate update when we intentionally rewrote a newsletter (e.g., after a typo fix). Moreover, the guard didn’t address the stale Prisma connection, so the same Error: Conn kept surfacing in later runs. The Implementation 1. Central Manifest ( metadata.json ) The manifest now lives at content/2026/08/08/content-automation/metadata.json . I added expli

The problem is not a lack of game content Most early game-guide sites begin as broad collections: a release-date post, a few news stories, a list of characters, perhaps a page titled "beginner guide." That structure looks complete in a sitemap but often fails the player who arrives from search with a precise, urgent question. They are not looking for a generic introduction. They are asking: Is the game out in my region? Can I join the playtest safely? Is the PC version confirmed? Does this game actually work like Tarkov, Sekiro, or Stardew Valley? What did the developer confirm, and what is still speculation? I have been building eight small game-guide sites around those moments. The project is an experiment in search-intent publishing : every useful page should answer one query well, show where its information came from, and make its uncertainty visible. The aim is not to create the biggest pre-release wiki. It is to create the most dependable next click. Example of the official-media trail used for Mistfall Hunter coverage. Public media can support a page, but it should never be used to invent mechanics that have not been confirmed. The editorial model: one question, one canonical answer A search-focused guide gets stronger when a reader can tell three things immediately: What the page answers. A release-status page should not compete with a separate news article for the same release-date query. How current the answer is. Status, configuration, test, and platform pages need a visible review date and a concrete update trigger. What is evidence and what is inference. Official store pages, developer announcements, and official videos form the baseline. Public footage is useful but does not prove every system detail. Community testing can be valuable, but it must be labelled and dated. This sounds obvious, but it changes the content plan. I do not add a new URL merely because a keyword has a close variant. I first ask whether a stronger existing page can be updated, l

When people think of Artificial Intelligence, they usually think of chat boxes. You type a prompt, text scrolls across the screen, and you copy-paste it. In the legal world, a chat box isn't enough. A contract on a screen is just a suggestion. A contract in hand—signed, sealed, and cryptographically verified—is a binding asset. As we build Lawyie (Sunverse AI’s intelligent legal infrastructure for Africa), one of our core mandates was moving beyond the chat interface. We needed a Document Factory. Here is the engineering breakdown of how we built an in-memory PDF generation pipeline that creates cryptographically-sealed legal documents in Python. 1. The Problem with Standard File Writing In standard Python web apps, saving a file usually means writing it to the local hard drive and then serving it. In a cloud environment like Streamlit Cloud, doing this at scale causes concurrency issues (multiple users overwriting the same contract.pdf file) and unnecessary disk read/write latency. The Solution: Everything must happen in-memory. 2. The In-Memory Buffer ( io.BytesIO / Byte-Streams) Instead of saving a file to the disk, we use Python’s io module to capture the PDF output directly as a byte-stream and feed it straight into the user's browser download button. Here is how the pipeline works using fpdf2 : from fpdf import FPDF import io def generate_legal_pdf ( contract_text , signature_id ): # 1. Initialize the PDF engine pdf = FPDF () pdf . add_page () pdf . set_font ( " Arial " , size = 11 ) # 2. Clean text (Handling special characters for Latin-1 encoding) clean_text = contract_text . replace ( " ₦ " , " NGN " ). replace ( " — " , " - " ) final_content = f " { clean_text } \n\n SECURE HASH ID: { signature_id } " # 3. Write to the document pdf . multi_cell ( 0 , 10 , txt = final_content ) # 4. Capture the output as bytes (Crucial for fpdf2) pdf_output = pdf . output () pdf_bytes = bytes ( pdf_output ) if isinstance ( pdf_output , bytearray ) else pdf_output return pdf

I’ve always liked the visual language of heraldry: shields, animals, symbols, colors, banners, and mottos that can tell a whole story in a single image. The problem is that creating a good coat of arms from scratch usually takes either design experience or a lot of time. So I built Coat of Arms Maker , an AI-powered tool that turns a plain-language description into an original heraldic design in seconds. 👉 Try it here: https://coatofarmsmaker.org/ What can you create? The tool works well for: Custom family-inspired crests Fantasy houses and kingdoms Tabletop RPG characters and campaigns Gaming clans and guilds Fictional organizations Personal emblems and decorative artwork You describe the symbols, colors, mood, and style you want. The generator interprets the brief as one coherent emblem and produces a polished design without requiring you to learn a complicated graphics editor. For example, you could ask for: A dark medieval shield featuring a silver wolf, a crescent moon, blue accents, and a banner representing courage and loyalty. Why I think it’s useful Most general-purpose image generators can make something vaguely heraldic, but getting the composition to feel like an actual emblem can take repeated prompting. I wanted the experience to be focused: describe the crest, generate it, and get a result designed around the conventions of heraldic artwork. The goal is not to replace official heraldic research or create a legally granted coat of arms. It’s a creative tool for people who want an original visual identity for a story, game, community, project, or family-themed gift. Built for non-designers There are no layers to manage and no complex controls to learn. If you can describe the idea, you can create the emblem. I’m continuing to improve the generator and would genuinely appreciate feedback from designers, fantasy writers, indie developers, and tabletop players. Give it a try and let me know what you create: 🔗 https://coatofarmsmaker.org/ If you have sugges

A lesson in dependency wars, version pinning, and the reality of building in public. Every founder dreams of a perfect launch. You hit "Deploy," the logo appears, and the users start flowing in. For Lawyie, my intelligent legal infrastructure for Africa, the launch started exactly that way. But then, the screen went blank. "Error running app." No red lines in the code. No obvious bugs in my logic. Just a silent failure at the very moment the world was starting to look. As the lead architect at Sunverse AI, I had to move from "Creator" to "Digital Detective." I pulled the logs from the Streamlit Cloud and found a cryptic traceback: TypeError: GZipResponder.__init__() missing 1 required keyword-only argument: 'thread_minimum_size' This wasn't an AI hallucination. This wasn't a database leak. This was an Infrastructure War. It turns out I had fallen victim to an industry-wide conflict. A core library called Starlette had recently updated to version 0.37.0+, changing its grammar for handling GZip compression. Meanwhile, the server environment hadn't caught up. In my requirements.txt , I hadn't specified a version. I just said "install it." Because I didn't "lock the door," the latest (and broken) version walked right in and crashed my entire engine. In a "Unicorn" startup, you don't just wait for things to get better. You force stability. I applied Version Pinning to my requirements. By hard-coding the stable version of the library, I overrode the server's defaults and restored the infrastructure: # The Pinned Shield streamlit>=1.35.0 starlette==0.36.3 # The specific fix for the GZip error supabase groq fpdf2 Building Lawyie from Abuja, Nigeria, taught me three things today: The Latest isn't always the Best: In production, stability beats "newness." Always pin your critical dependencies. Logs are your best friend: When the screen goes blank, don't panic. Read the trace. The answer is always in the bytes. Transparency builds Trust: When my community on Dev.to pointed out

I'm a self-taught developer. No CS degree, no funding, no team. Just me, a laptop, and a problem I kept watching people struggle with. The Problem Every freelancer and small agency I know deals with the same mess: client details scattered across WhatsApp chats, email threads, Google Drive folders, and random Notion pages. Nothing lives in one place. When a client asks "wait, didn't we already send you the logo files?" you're digging through three different apps trying to remember. I didn't just hear about this problem — I lived it. So four months ago, I started building Kray. What Kray Actually Does Kray gives freelancers and agencies one organized workspace per client — projects, links, and notes, all in a single place instead of scattered across five different tools. The part I'm most proud of: when you share a project with a client, they can open the link and see everything instantly — no sign-up, no account creation, no friction. Just a clean, simple view of what they need to see. The Stack Since I was building this entirely solo with zero budget, I leaned on tools that let me move fast without infrastructure headaches: React 19 + Vite + TypeScript (strict mode — no shortcuts) Tailwind v4 for styling Supabase for auth, database, and storage Deployed on Vercel No backend servers to manage. No DevOps to worry about. Just me shipping features. What I Learned Building Solo You will hit bugs that eat entire days. I spent hours debugging a sitemap indexing issue that turned out to be one missing header. That's the job — most of building isn't writing new features, it's fixing the thing that should've worked but didn't. Deploy discipline matters more than you think. I once tested a feature locally, assumed it was live, and spent 20 minutes confused about why production wasn't behaving — because I'd forgotten to push. Lesson learned: always verify what's actually deployed before debugging further. Marketing is its own skill, and it's humbling. I've spent the last severa

Recently, I’ve been spending more time building small projects on my own. One thing I’ve learned is that it’s usually better to keep things simple and ship early instead of trying to make everything perfect. A small project can still teach you a lot about coding, deployment, design, and how people actually use what you build. I’m planning to share some of my development notes and experiments here from time to time. Looking forward to learning from everyone on DEV.

Most AI image generators look like a prompt box with a Generate button. That is also how my first version started. But once real users entered the workflow, the difficult problems appeared somewhere else: browser refreshes, external task IDs, reference images, partial failures, credit refunds, private assets, and public artwork moderation. While building Magggic , I learned that an AI image generator is less like a form submission and more like a small distributed job system. This article covers the decisions that made that workflow more reliable. The code samples below are intentionally simplified. The important part is the shape of the workflow, not a specific database or image provider. The prompt box is only the beginning A synchronous prototype is easy to imagine: const images = await provider . generate ( prompt ); return images ; That version works until the request takes a minute, the provider times out, one of four requested images fails, or the user refreshes the page. The production workflow I needed looked more like this: Prompt + references ↓ Create a local queued task ↓ Charge credits with an idempotency key ↓ Submit work to the image provider ↓ Persist every completed output immediately ↓ Finalize the task and refund failed outputs ↓ Keep the result private until the user publishes it The provider request is only one step. The local task is the source of truth for what the user sees. 1. Persist the task before calling the provider The first important decision was to create a generation record before making the external API request. A generation stores the information needed to reconstruct the job: type Generation = { id : string ; userId : string ; idempotencyKey : string ; prompt : string ; referenceImages : string []; model : string ; ratio : string ; resolution : string ; count : number ; cost : number ; status : " queued " | " generating " | " completed " | " failed " ; outputs : string []; providerRequestIds : string []; failureReason : string |

Hey everyone! 👋 I'm a developer who got tired of visiting 10 different websites to do simple tasks like formatting JSON, compressing images, or generating QR codes. So I built DevToolBox — a single place with 15+ free online tools, all running in your browser with no sign-up required. 👉 https://toolbox-site.asia Why I Built This Every time I needed a quick tool, I'd end up on a site full of ads, popups, or "create an account to continue" walls. I wanted something clean, fast, and respectful of users' time and privacy. The idea was simple: one website, all the tools you need, zero friction. What's Inside Here are some of the tools available: Developer Tools: JSON Formatter & Validator — Format, validate, minify JSON with syntax highlighting Base64 Encoder/Decoder — Encode and decode Base64 strings instantly UUID Generator — Generate v4 UUIDs in bulk 🔧 Unix Timestamp Converter — Convert between timestamps and human-readable dates 🔧 Regex Tester — Test regular expressions with real-time matching 🔧 Markdown Preview — Write Markdown and see the output live Hash Generator — MD5, SHA-1, SHA-256, SHA-512 🔧 Diff Checker — Compare two texts side by side Daily Tools: 🖼️ Image Compressor — Compress images right in your browser Image Format Converter — Convert between PNG, JPG, WebP Password Generator — Create strong, customizable passwords 📱 QR Code Generator — Generate QR codes with custom colors BMI Calculator — Calculate Body Mass Index 🎂 Age Calculator — Calculate exact age from birth date 📝 Word Counter — Count words, characters, sentences 📏 Unit Converter — Length, weight, temperature, and more How It's Built The whole site is a Vue 3 + TypeScript + Vite project with Tailwind CSS for styling. Everything runs client-side — no data is ever sent to a server, which means your data stays on your device. Key tech: Vue 3 with Composition API TypeScript for type safety Vite for blazing fast dev experience Tailwind CSS for styling Vue Router with history mode for clean URLs vue-i1

Bridging Design and Code to Empower Local Businesses As a full-stack developer specializing in JavaScript and React, one of the most exciting ventures I'm currently on is building ready-made websites and Next.js templates through Softchic. This isn't just about coding; it's about deeply understanding the needs of businesses, particularly within the vibrant and rapidly evolving Nigerian market, and translating those into high-performance, beautiful web solutions. Why Next.js? Performance, SEO, and Developer Experience My choice of Next.js as the primary framework for these templates was deliberate: Performance: Server-side rendering (SSR) and static site generation (SSG) capabilities are crucial. In areas where internet speeds might vary, a fast-loading website isn't just a nice-to-have; it's essential for user retention and conversion. SEO: For businesses looking to establish a strong online presence, robust SEO capabilities out-of-the-box mean our templates provide a solid foundation for discoverability. Developer Experience: Building with Next.js allows for efficient development, leveraging the power of React while simplifying routing, data fetching, and API routes. This means faster iteration and higher quality templates. The Nigerian Market: Unique Challenges, Immense Opportunity Crafting templates specifically for the Nigerian market presents a fascinating set of considerations: Design Aesthetics: Understanding local preferences in terms of color palettes, layouts, and user flows is critical. It's not just about what looks good globally, but what resonates locally. This is where my dual role as creative director for promotional materials comes into play – applying that eye for design directly to the templates. Mobile-First Mentality: A significant portion of internet users in Nigeria access the web via mobile devices. Every template is meticulously designed with a mobile-first approach to ensure optimal responsiveness and user experience on smaller screens. Aff

Hey everyone, it's your friendly neighborhood dev-dad here. Mid-thirties, full-time engineer by day, battling AI trading bots by night (weekends, really). Today, I want to share a subtle but potentially catastrophic bug I found in my bot. Seriously glad I caught this before deploying with real money. The symptom: Discord notifications for order fills just weren't arriving. The culprit: I forgot to load my .env variables consistently across multiple Python scripts. This is a super common pitfall when you're linking several Python scripts in a personal project, and it can be a real headache. What Happened: A "Silent Failure" Uncovered by a DRY_RUN Last weekend, I was running my usual DRY_RUN tests for my FX bot. My bot's logic is split into two main parts: planner.py , which strategizes trades, and executor.py , which actually sends orders to the exchange. The console logs looked perfectly normal. executor.py seemed to be doing its job: I saw messages like "[DRY_RUN] Order placed: ...". But the Discord notifications, which should have been firing, never appeared. At first, I thought it was a Discord outage or just a delay. But after 30 minutes, nothing. Something was definitely wrong. Thinking about what would have happened if this were real money sent shivers down my spine. "I thought I placed an order, but it never went through." "I thought I closed a position, but I was still holding it." Bugs in notification systems are terrifying because they create these silent failures. You think everything is okay, but it's not. This is precisely how real money gets lost. The Investigation: Unmasking the Culprit To narrow things down, I first tried calling notify.py (which handles all notifications) directly. It worked flawlessly; the Discord notification came through. This pointed to an issue within executor.py , which calls notify.py . I re-examined executor.py 's logs more carefully and immediately saw it: the webhook URL being passed to the notification function was None .

Hey everyone, it's your friendly neighborhood senior dev here. I'm 38, working as a full-time engineer during the week, and tinkering with AI-powered algorithmic trading bots on the weekends. Today, I want to share a story about a subtle but potentially catastrophic bug I found in my bot. Seriously, thank goodness I caught this before deploying with real capital. The TL;DR: My Discord notifications for order confirmations weren't firing, and the culprit was a forgotten .env load across multiple Python scripts. I think this is a pretty common pitfall when you're working on personal projects with several interconnected Python scripts. What Happened: A "Silent Failure" Uncovered by DRY_RUN Over the weekend, I was running my usual DRY_RUN tests for my forex bot. My bot's architecture splits responsibilities: planner.py handles strategy logic, and executor.py executes actual trades on the exchange. Looking at the console logs, executor.py seemed to be working perfectly. I saw logs like [DRY_RUN] Order placed: ... . But the Discord notifications, which are supposed to arrive after an order, simply weren't showing up. Initially, I thought it might be a Discord issue or just a delay. But after 30 minutes, still nothing. This felt wrong. The thought of this happening with real money sent shivers down my spine: "I thought I placed the order, but it never went through." "I was sure I closed that position, but it's still open." Bugs in notification systems are notorious for creating these kinds of silent failures, and they're genuinely scary. The Investigation: Aha! Found You... My first step was to isolate the problem. I directly invoked notify.py , the script responsible for sending notifications. It worked perfectly, sending a test message to Discord. This strongly suggested the issue was upstream, likely within executor.py , which calls notify.py . I took a closer look at executor.py 's logs. And there it was: the webhook URL, which should have been passed to the notificati

For a while, I spent more time reading about SEO than actually doing SEO. Keyword research, domain authority, backlinks, technical SEO, search intent—there was always another guide to read and another tool to try. Eventually, I decided to stop preparing and build a small website from beginning to end. The result is Get Password Generator , a free password generator that creates passwords entirely inside the browser. This is what I have learned so far. Step 1: Finding a keyword with Google Trends I started with Google Trends. Google Trends does not provide exact search volume, but it is useful for comparing keywords and checking whether people’s interest is stable, growing, or disappearing. Instead of looking for the “perfect” keyword, I wanted to find something that: solves a clear problem; can become a focused single-purpose tool; has relatively stable demand; does not require a large backend; can be shipped quickly. A password generator matched those requirements. People already understand what the tool should do, and there is no complicated onboarding process. They open the page, choose their settings, generate a password, and copy it. Step 2: Checking the actual Google results After looking at trends, I searched the keyword directly on Google and examined the first page. This step was more useful than looking at a single difficulty score. I checked: what kinds of pages were ranking; whether the results were tools, articles, or product pages; how quickly users could access the generator; whether the pages worked well on mobile; how clearly they explained privacy and security; whether there was room for a simpler experience. I was not trying to prove that the keyword was “easy.” Search results can change, and established websites are difficult to compete with. I only wanted to answer a practical question: Is there enough room here to build something useful and learn from the process? For me, the answer was yes. Step 3: Buying the domain I purchased: https://getpas

I'm building PetSignal — a browser-based AI that reads dog and cat body language from a photo and flags stress signals (whale eye, freezing, lip curl) before they escalate. It's a solo project, the core purchase is a $2.99 credit pack, and that one number dictates the entire growth strategy. Here's the math that rules everything: at a ~$3-10 one-time AOV, paid ads can never work. US pet-niche CPC runs $0.5-2; even at optimistic conversion rates you're paying $50+ to acquire a $3 customer. So the product lives or dies on organic search. That constraint turned out to be a gift — it forced me to treat SEO as an engineering discipline with real feedback loops instead of a checklist. Twenty-eight days of Search Console data later: 230 clicks, 15,953 impressions, and impressions in the second half up 105% over the first. Small numbers, real slope. These are the five things the data actually taught me. 1. Symptom pages beat product pages — but not the way I expected My content engine is ~35 "symptom pages": Dog Opening and Closing Mouth Repeatedly , Cat Whale Eye , Cat Breathing Fast . Each one answers a moment of owner anxiety that ends with a photo the owner has already taken — which is exactly what the product analyzes. The surprise: one page carries 54% of all clicks. Not the homepage, not the tool pages — a page about dogs opening and closing their mouths. Meanwhile my four "commercial" analyzer pages have CTRs of 6-9% (site average: 1.8%) but almost no impressions. The lesson: content pages find demand, commercial pages convert it, and internal links are the pipe between them. I spent a day rebalancing internal links after realizing my refund policy — sitemap priority 0.4 — carried roughly twice as many site-wide links as any commercial page, while the general-purpose analyzer had exactly zero editorial links pointing at it. 2. Every page is data, not HTML All 35 symptom pages live in one TypeScript file as structured objects: title, quickAnswer, sections, tables, re