标签：#buildinpublic

Há alguns meses, pagando $7/mês por um servidor de 512MB no Render pra hospedar uma API de um projeto da escola, decidi entender como esse tipo de infraestrutura funciona por baixo — e construir a minha própria versão. O resultado é o Arctis Deploy : uma plataforma de deploy contínuo via Git, com Docker isolado por projeto. Esse post é sobre como ela funciona por dentro. Arquitetura geral Frontend (Next.js) │ ▼ Backend (Go + Fiber) — Clean Architecture │ ├──► Deploy-Agent (roda em cada servidor) → Docker └──► Database-Agent (provisiona MySQL/Postgres) em desenvolvimento, ainda não disponível para usuários Cada servidor de produção roda um deploy-agent próprio. O backend central envia comandos via HTTPs autenticado e o agent executa o que for necessário — clone, build, container, métricas. O pipeline de deploy Todo deploy passa por 5 etapas sequenciais: clone — git clone --depth 1 , otimizado pra trazer só o necessário analyze — detecta o framework automaticamente lendo package.json , requirements.txt , go.mod , etc. build — gera um Dockerfile multi-stage específico pro framework detectado (timeout: 15min) deploy — sobe o container na porta alocada, com limites de CPU/RAM aplicados health check — faz requisições até o container responder, com rollback automático em caso de falha Cada etapa emite logs estruturados ( info / warn / error ), transmitidos via WebSocket em tempo real pro frontend. Detecção automática de framework Next.js, React, Vue, Node.js, e sites estáticos. A detecção é baseada nos arquivos do repositório — o usuário só conecta o Git e dá push. Outros detalhes Pool de recursos : cada plano define um total de Projetos/CPU/RAM/disco que o usuário distribui livremente entre seus projetos Auto-sleep : no free, containers sem tráfego são pausados ( docker pause ) — não destruídos — e despertam automaticamente na próxima requisição Domínios : subdomínio automático ou domínio próprio, com SSL via Cloudflare Pagamentos : MercadoPago integrado, planos em real V

I spent a weekend wiring Google's Gemini and Veo APIs into a single app just to feel where the edges of multimodal AI actually are. It turned into a small studio I now use daily, and along the way I learned more about these models from plumbing them than from any paper. Here's the honest technical debrief. Three pipelines, three completely different problems I wanted one prompt box that could do video, image editing, and document Q&A. Naively I assumed they'd share most of the stack. They don't. 1. Image-to-video: the enemy is time, not pixels Generating one good frame is solved. Video is about temporal coherence — frame 13 must agree with frame 12 or you get flicker and identity drift. Modern video models treat the clip as one object in space and time (latent diffusion over a width x height x time volume, with spatiotemporal attention) rather than 120 independent images. Conditioning on a reference image as the first frame is what makes image-to-video feel controlled: you've handed the model a strong anchor and asked it to extrapolate motion, not invent a world. The surprise: native audio sync (Veo 3.1 generating clip + soundtrack jointly) does more for perceived realism than another notch of resolution. A door slam landing on the exact frame the door shuts is uncanny in a good way. 2. Instruction-based image editing: preservation is the hard part Generating is unconstrained; editing must change one thing and preserve everything else. Condition the diffusion model on both the instruction and the source image's latents, cross-attend the instruction to steer only the referenced region, and bias hard toward preserving unedited latents. Push that preservation too soft and the subject's face quietly morphs across edits — the classic 'character consistency' failure that makes or breaks storytelling use-cases. 3. PDF chat: it's retrieval, not a long context The naive 'paste the whole PDF' approach dies on long files (models get lost in the middle ) and costs you the full

I Built a GDPR Compliance Scanner Using the Claude API - Here's How It Works A few months ago I noticed something that kept bugging me. I was building and handing off websites for clients and every single time, GDPR compliance was either an afterthought or a panic right before launch. Privacy policies copied from templates, cookie banners slapped on at the last minute, no one really sure if the contact form was actually compliant. The bigger problem: there was no quick, affordable way to check . Enterprise compliance tools cost hundreds per month. Legal consultants cost more. Most small businesses just crossed their fingers. So I built ClearlyCompliant - an automated GDPR compliance scanner that analyses a website and delivers a detailed PDF report for a one-off fee. No subscription, no jargon, just a clear picture of where a site stands. Here's how it actually works under the hood. The Stack Django (Python) - backend and web app BeautifulSoup + requests - crawling and HTML parsing Python threading - async scanning without the overhead of Celery/Redis Anthropic Claude API (Haiku) - AI-powered policy analysis ReportLab - PDF report generation Stripe - payments IONOS SMTP - email delivery Gunicorn + Nginx on an IONOS VPS The Scanning Pipeline When a user submits a domain and completes payment, the scan kicks off immediately. Rather than making them wait on a loading screen, the scan runs asynchronously in a background thread and the report gets emailed when it's done. I deliberately avoided Celery and Redis here. For the scale I needed, Python's built-in threading module was more than sufficient and kept the infrastructure simple. One less thing to maintain, one less thing to break. import threading def run_scan_async ( domain , order_id , customer_email ): thread = threading . Thread ( target = run_full_scan , args = ( domain , order_id , customer_email ) ) thread . daemon = True thread . start () The scan itself runs 23 individual GDPR checks across several categori

The Problem Wasn't Writing It was starting. Sometimes I wanted: A social media caption A motivational quote A writing prompt A meaningful message But my mind would go completely blank. Not because I had nothing to say. Because: Coming up with the right words at the right moment is surprisingly difficult. We've All Done This Open a new tab. Search: "Motivational quotes" "Success quotes" "Life quotes" "Funny quotes" Scroll for 10 minutes. Copy one. Close the tab. Why I Built This Tool So I built something simple: 👉 https://allinonetools.net/quote-generator-tool/ A tool that instantly generates quotes across different categories. Whether you need: Motivation Success Life Leadership Creativity Social media inspiration You can generate quotes in seconds. No signup. No setup. Just: Click → Generate → Use What I Realized People don't always look for quotes because they need content. Often they're looking for: A different perspective. A good quote can do something interesting. It can say in one sentence what takes us paragraphs to explain. The Surprising Part The most popular quotes are rarely complicated. They're simple. Short. Easy to remember. Yet somehow they stick with us for years. Why Quotes Still Matter In a world full of endless content: Attention is limited Time is limited Patience is limited A strong quote delivers an idea instantly. That's powerful. The Problem With Searching Manually Most quote websites feel: Cluttered Slow Full of ads Hard to browse And sometimes you spend more time searching than actually reading. What I Focused On I wanted the experience to feel: Fast Clean Inspiring Fun to explore Because finding inspiration shouldn't require effort. What Surprised Me After building it: Some people used it for: Social posts Presentations Daily motivation Writing inspiration But one thing surprised me most. People kept generating quote after quote. Not because they needed one. Because they enjoyed discovering them. The Real Insight Sometimes tools aren't abo

Somewhere along the way, computing became disposable. Devices became sealed. Systems became rented. Ownership became licensing. Repairability disappeared. Infrastructure moved away from the user and into distant cloud platforms. And I think we lost something important because of it. Lately, I’ve found myself becoming increasingly interested in hardware again. Not just software. Not just cloud systems. But actual computing devices. Servers. Home infrastructure. Repairable machines. Set-top systems. Local AI appliances. Sovereign computing. Because I believe the next era of computing will belong to people who own their infrastructure again. The Provider Box Realization One thing that kept sticking in my head was this: Almost every home in America already has a provider box. A Comcast box. An AT&T gateway. A router. A modem. A streaming box. People are already comfortable with the idea of a dedicated computing appliance sitting in their home quietly powering their digital life. That realization changed how I thought about computing infrastructure. What if those boxes worked for the user instead of the provider? What if they: hosted local AI, managed home storage, coordinated smart devices, powered media systems, handled automation, protected privacy, synchronized intelligently, and operated as sovereign infrastructure? That idea became part of the thinking behind KiwiHome. The Return Of Home Infrastructure For a long time, the industry moved toward centralization. Everything shifted toward: SaaS, subscriptions, streaming, cloud storage, cloud intelligence, and rented operational environments. Convenient? Absolutely. But also fragile. If: pricing changes, services disappear, companies shut down, APIs get revoked, or platforms change policies, entire workflows collapse overnight. I think people are starting to feel that tension. Especially creators. Especially businesses. Especially technical users. That’s why I believe we’re going to see a major resurgence in: home serv

May 25, 2026. This is not just another date on my calendar. This marks the beginning of one of the biggest professional transitions of my life. After nearly a decade working in the world of IT infrastructure, technical support, networking, field engineering, and systems operations, I’ve made a decision that has been building in my mind for some time: I am transitioning into Data Analytics. And this is where I document that journey—publicly, honestly, and in real time. Not when I become an expert. Not when I feel “ready.” Not when everything looks polished. I’m starting now. Because real growth is rarely clean, predictable, or perfectly planned. Sometimes it starts with one uncomfortable decision: To leave what you already know… and step into what your future requires. Where My Journey Started Before data, before dashboards, before writing my first SQL query or building my first analytics project—my career started in the trenches of IT. For the past 10 years, I’ve built my career solving real technical problems across businesses, organizations, schools, offices, and field operations. My world has been cables, routers, networks, system failures, installations, troubleshooting, and making technology work where others saw complexity. Over the years, I’ve worked deeply in: Computer troubleshooting and hardware diagnostics Printer setup, configuration, and enterprise support Wi-Fi deployment and hotspot installations LAN design and structured network deployment Fiber optic installations and network termination Data cabling and structured cabling systems CCTV surveillance installation and maintenance Alarm systems and electronic security integration Intelligent security systems Electric fence installations and perimeter protection systems Router, switch, and access point configuration End-user support and enterprise technical troubleshooting Systems maintenance and operational support I’ve spent years on ladders, in server rooms, inside offices, on construction sites, insi

There's a pattern I've noticed with every new AI coding tool that comes out: they all want you to switch editors. Or open a new terminal. Or context-switch into some standalone app. I DON'T WANT TO DO THAT My entire dev workflow lives in VS Code. My keybindings, my split panes, my snippets, my extensions — all of it. When Google released the Antigravity CLI ( agy ), an agentic coding assistant, I genuinely liked what it could do. But to use it properly, I had to live in a terminal window, manually managing sessions, typing slash commands from memory, and losing my editor context entirely. So I built a VS Code extension for it instead. What is Antigravity? Google Antigravity is Google's agentic coding CLI — think of it as a Gemini-powered dev assistant that can read your project, run tools, execute terminal commands, and help you build. It's the kind of tool that can handle complex multi-step tasks, not just autocomplete. The CLI is called agy , and it's genuinely capable. The problem was the workflow: terminal-first, session management by hand, and no visual layer over the context you're already in. The Extension: Antigravity for VS Code Install it on the VS Code Marketplace Source on GitHub The core idea is simple: the extension is a UI layer. It never bundles or replaces the agy binary — it shells out to whichever version you have installed locally. Same philosophy as the Claude Code VS Code extension: the editor provides the surface, the CLI does the work. Here's what it actually does: Sessions List The sidebar panel opens to all your saved sessions. You can open an existing one, delete it, or start fresh. New sessions can be launched in sandboxed mode or with permissions bypassed — accessible right from the "New Session" overflow menu, without memorizing CLI flags. Any session with an active turn shows a loading indicator in its row, so you always know what's in flight. Chat Panel (Material 3 Expressive) This is the main surface. Each session runs its own live,

10 Prompt Patterns I Use Every Single Day Last Tuesday I spent 40 minutes arguing with Claude about a database schema before I realized I had never told it what I already tried. I described the problem, it gave me the same three suggestions I had already ruled out, I pushed back, it apologized and gave me variations of the same three suggestions. The entire session was garbage because I started from zero instead of from where I actually was. I closed the tab, rewrote my first message, and had a working solution in six minutes. That gap — between how most people prompt and how it actually works when you treat the model like a collaborator who needs real context — is what this post is about. Pattern 1 & 2: Lead With What You Already Tried, and State the Constraint That Binds You These two patterns are almost always used together, so I won't pretend they're separate. When you describe a problem without the history of your attempts, you are forcing the model to rediscover your dead ends. Every developer knows this frustration: you explain a bug, get back a solution you tried on Monday, explain you tried that, get a variation, explain that too — it's a recursive waste. The fix is brutal honesty upfront: "I need X. I already tried A and B. A failed because [specific reason]. B is off the table because [constraint]. Don't suggest either." The constraint layer is the other half. Models are optimists by default. They will give you the architecturally clean, perfectly testable solution that requires three new dependencies and a refactor of your auth layer. Unless you tell them you are shipping in two days, can't add dependencies, and the code needs to be readable by someone who last touched Python in 2019. Constraints aren't limitations on the answer — they are the answer. Front-load them or you will spend the session rejecting suggestions that are technically correct but situationally useless. Pattern 3 & 4: Output First, Reasoning After — and Diff Only, Not Rewrites Two sid

Day 48 of building GoDavaii, and the toughest problem isn't the sheer volume of allopathic medicines or the complexity of their interactions. It's the invisible logic of 'Desi Ilaaj' - the home remedies and traditional practices deeply ingrained in Indian families for generations. When everyone knows the comfort and efficacy of 'haldi-doodh' (turmeric milk) for a cold, how does an AI health platform authentically verify and integrate that knowledge without replacing professional medical advice? This isn't just a cultural nod; it's a fundamental challenge for any health AI truly built for India. Global competitors like Epocrates or drugs.com, while excellent within their scope, are entirely English-centric and focused on Western allopathic data. They have no framework for the millions of people who search for health guidance in Hindi, Tamil, or Marathi, and whose first instinct for a cough might be a herbal concoction, not an over-the-counter syrup. The Unspoken Truth About India's Health Landscape For a vast majority of Indian families, health decisions often involve a blend of modern medicine and traditional wisdom. From specific herbs to dietary adjustments passed down through generations, these practices are effective for many minor ailments. Yet, in the digital health space, they're largely ignored. Why? Because the data is fragmented, often anecdotal, and doesn't fit neatly into structured pharmacological databases. It's a goldmine of practical health knowledge, but also a minefield for safety if not handled with care. My realization as Pururva Agarwal, 27-year-old founder of GoDavaii, was simple but profound: if we truly want to serve families coming online in their mother tongue, our AI needs to understand and interact with this context. This means going far beyond just translating English medical terms into 22+ Indian languages. It means building a knowledge graph that can intelligently cross-reference traditional remedies with known active compounds, potent

I've been building a static Astro site on Cloudflare Pages over the last few weeks. Sharing the 3 deployment bugs that cost me the most time, in case they save anyone else the same loop. Setup Astro 5 + Cloudflare Pages + Tailwind 4. Content lives in a few JSON files; each page is a dynamic route mapped over the data. Free-tier hosting, no backend. Standard static-first stack. Bug 1: Trailing-slash 307 chain I started with trailingSlash: 'never' in Astro config. Build output went to dist/foo/index.html . Result: Astro emitted canonical tags as /foo (no slash), but Cloudflare Pages served /foo/ (auto-adding the slash via 307). Google Search Console flagged pages as "Redirect error" because the canonical URL pointed at a redirect chain instead of a real 200. I first tried build.format: 'file' to get flat dist/foo.html output, hoping that would bypass the trailing slash. That made it worse — Cloudflare still 307-stripped, but now to a non-existent .html file → 404. Fix: stop fighting the platform. ​ js // astro.config.mjs export default defineConfig({ trailingSlash: 'always', // ... }); ​ trailingSlash: 'always' plus default directory build aligns the canonical URL with what Pages actually serves. The redirect errors resolved on next re-crawl. Bug 2: _redirects rejected at deploy I tried to do a www → apex 301 in public/_redirects : https://www.example.com/* https://example.com/:splat 301! Cloudflare rejected the deploy with three validation errors: ​ Line 13: Only relative URLs are allowed. Line 22: Duplicate rule for path /foo. Line 23: Duplicate rule for path /bar. ​ Pages tightened _redirects validation — absolute-URL sources aren't accepted anymore. The duplicate errors were because Astro's own redirects config in astro.config.mjs generates HTML meta-refresh files that Pages parses as implicit redirect rules — conflicting with my explicit ones. Fix: delete _redirects entirely. Use a Cloudflare Redirect Rule from the dashboard for cross-host 301s (Wildcard pattern,

I am a full time trader and part time developer based in Karachi, Pakistan. A year ago I sat down to research how to properly compare brokers on the Pakistan Stock Exchange. Three hours later I had 11 browser tabs open, two of which had broken links, one had data from 2019, and none of them had everything I needed in one place. So I built PSX Pulse. What PSX Pulse Is PSX Pulse is a free stock market education platform for Pakistani retail investors. Everything a beginner needs to start investing in Pakistan's stock market — in one place. What is live right now: 35 verified SECP-licensed brokers with full contact details Complete mutual funds directory across 15 AMCs DCA calculator with realistic return scenarios 30-day beginner learning path Islamic investing guide PSX sector guide covering 12 sectors IPO tracker 100-term searchable glossary Weekly market recap every Friday All free. No login required. Live at: https://psxpulse.xwen.com.pk/ The Stack React + Tailwind CSS for the frontend. Vercel for hosting — free tier handles everything comfortably. No backend for most features — localStorage and static data keeps it fast and simple. Newsletter handled via a serverless Vercel function writing to a private GitHub CSV. What I Learned Building This Solo 1. The information gap in emerging markets is enormous Pakistani investors are not underserved because nobody cares. They are underserved because nobody with the technical skills to build tools also has the market knowledge to know what those tools should do. Being both a trader and a developer turned out to be the actual unfair advantage. 2. Free tools beat content for SEO My DCA calculator and broker directory pages get more consistent Google clicks than any article I have written. Tools solve a specific search intent that AI overviews do not replace — people still need to interact with a calculator, not just read about one. 3. Building in public is uncomfortable but worth it Sharing what you are building before it i

In the first post I told you the story: 20 years as a developer, six months of being scared of AI, $800 in burned tokens, and a stubborn agent named Claudio who taught me — by failing over and over — how to ask for things properly. This post is the method that came out of all that pain. Five rules, one per letter of FORGE. I want to be honest about one thing up front: this is not a framework I invented at a whiteboard. Every rule here is a scar. Each one is the lesson from a specific mistake that cost me money, time, or sleep. I'm going to tell you the mistake first, and then the rule. Because the rule only makes sense once you've felt the pain that created it. Let's go. First, the idea behind all of it Here's the thing nobody told me when I started: A task is not a post-it. It's a contract. When you ask an AI agent for something with no structure, you're not giving an order — you're placing a bet. The agent interprets, assumes, improvises, and the result depends on how much context it managed to reconstruct on its own. Sometimes it guesses right. Often it doesn't. And you only find out after the tokens are gone. The Forge Method is the agreement between you and your agents: you bring the structure, they execute with precision . That's it. Five rules to hold up your end of that contract. F — Focused The mistake: My early tasks had titles like "Fix bug" and "Update stuff." I'd come back twenty minutes later to find the agent had fixed a bug — just not the one I meant. It wasn't wrong. It just had no way of knowing which thing I was talking about. **The rule: **If the title is vague, the task is vague. Vague in, vague out. A focused title needs a domain, an action, and a scope. Two words minimum, and no generic placeholders. ❌ Rejected: - "Fix bug" - "Update auth" - "Do the thing" ✅ Accepted: - "Fix authentication timeout on Nginx reverse proxy" - "Update JWT expiry from 1h to 24h in src/auth/config.ts" The test: Read the title with no context. Do you know the domain,

Six months into running my SaaS, my "feedback system" was three browser tabs, a starred Gmail folder, and a sticky note on my monitor that said "check Discord." That was the whole system. It held together until the day I found a three-paragraph email from a paying user — a genuinely detailed feature request with a real use case — sitting unread for 24 days. His last line was: "Happy to pay more if you can support this." I replied the same afternoon I found it. His reply: "Switched last week, thanks anyway." That was the moment I stopped treating feedback management as a nice-to-have. Why the usual fixes didn't fix anything I tried the obvious things first. I want to document them because I see a lot of people cycling through the same failed solutions. Notion database 🪦 Built a beautiful one. Color-coded tags, priority columns, status tracking. It lasted 11 days before nobody — including me — was maintaining it. The friction of "open Notion, find the right database, fill in six fields" is invisible when you're designing the system and fatal when you're in the middle of a support conversation. Airtable form 🪦 Better entry point, still disconnected from where users actually were when they had feedback. Nobody bookmarks your Airtable form. They DM you on Discord and you think "I'll add that later" and you don't. Canny — this one actually worked, for a while I genuinely liked Canny. Clean interface, users could upvote requests, I could see what was popular. It felt like a real system. Then our user count grew and the pricing tier jumped. I was looking at $99/month for a feedback board for a product still finding its footing. That's not a moral judgment on Canny — it's a fair product — but for a bootstrapped indie dev, it started feeling like a tax on momentum. The deeper problem with all three solutions was the same: they were inboxes, not loops. User submits → enters the void → user never knows if anyone saw it → user assumes nobody did → trust erodes → churn. I had bui

> TL;DR — I run four different domains off one Next.js codebase: a marketing site at pagestrike.com , an authenticated app at app.pagestrike.com, a public publishing domain at pagestrike.app, and customer-owned domains. The trick isn't deploying four apps — it's a single proxy.ts that reads the host and rewrites/redirects/passes-through per-request. This post walks through why I chose this shape, the parts I got wrong, and the cookie-domain trick that makes it all stick. Stack: Next.js 16 App Router , Supabase , Vercel , one proxy.ts file (~370 lines). This is the second post in my build-in-public series on PageStrike . Last week I wrote about the 6-CTA architecture — modeling conversion intent as a discriminated union so one launch could be a checkout, a COD form, or a calendar booking. This post is about a different primitive: modeling host as routing context so one codebase can serve four very different audiences. Why four domains, not one Most SaaS apps live at one domain — say myapp.com with /dashboard under it. That works until you grow into edge cases that don't fit: Marketing pages get spammed by your own dashboard headers. Your marketing nav says "Sign in / Pricing / Blog". Your dashboard nav says "Launches / Contacts / Settings". You either A/B them with conditional logic everywhere or you live with the noise. Public user-generated pages share your domain reputation. When a customer publishes a landing page at myapp.com/p/[slug] , every spammy LP from a free-tier user drags down myapp.com 's sender reputation, search trust, and ad-account standing. Google and Meta penalize the host, not the path. Custom domains don't route cleanly. A customer who buys acmewidgets.com and points it at your app expects their LP at acmewidgets.com/ — not myapp.com/p/acme-widgets . You need a rewrite that's transparent to the visitor, doesn't 404 on _next/static/* , and survives RSC prefetches. I split PageStrike — a free AI landing page builder — across four hosts to solve al

In Part 14 , I finished HMAC webhook signing. The backend was complete — JWT auth, PostgreSQL, Redis caching, rate limiting, circuit breaker, worker pool, webhook delivery, migrations, Docker. All running locally. But "runs on my machine" isn't a portfolio project. It's a homework assignment. Time to ship it. The Stack Being Deployed Go backend — ~15MB Docker image (multi-stage build, CGO_ENABLED=0) PostgreSQL 16 — with golang-migrate running schema migrations on startup Redis — for caching, rate limiting, and refresh token storage Oracle Cloud Free Tier — 1GB RAM, 45GB disk, already provisioned Everything wired together with docker-compose.yml . One command to start the entire stack. Step 1: The VM Was Fine, Actually I was worried about the free tier specs. Turned out the "1GB" in the tier name refers to RAM, not disk. The actual disk is 45GB — plenty. free -h # 954MB RAM, 552MB available df -h # 45GB disk, 41GB free The real constraint: no swap . Go's compiler is memory-hungry. Without swap, building the Docker image on the VM would exhaust RAM and kill the process. More on this in a moment. Step 2: Install Docker curl -fsSL https://get.docker.com | sudo sh sudo usermod -aG docker ubuntu newgrp docker The official install script handles everything — Docker Engine, containerd, Docker Compose plugin. One command, done. Step 3: Clone the Repo The repo is private. Created a fine-grained GitHub personal access token with Contents: Read-only permission. Used it to clone: git clone https://TOKEN@github.com/absep98/Go_learn.git Security note: never paste tokens in chat, email, or anywhere visible. Type them directly into the terminal. Tokens in chat history are compromised tokens. Step 4: Create the .env File The .env from my local machine needed two changes for Docker: # LOCAL (wrong for Docker): DB_HOST = localhost REDIS_HOST = localhost # DOCKER (correct): DB_HOST = postgres # ← service name in docker-compose.yml REDIS_HOST = redis # ← service name in docker-compose.ym