7 Infra Improvement Strategies to Prevent Next.js Deployment Build Failures in 2026 Recently, our team's deployment pipeline started showing serious instability. Specifically, we encountered recurring build failures related to the chat build. As a result, the entire development team was preoccupied with battling these build failures. Attempts and Pitfalls Initially, I thought the --preload detection logic was the problem. I modified it to detect only specific lines, but this ended up causing issues in other areas. The recurring chat build failures were actually caused by the next.config file not properly recognizing file extensions. I modified it to allow extensions like .mjs , .js , .ts , and .cjs , but even that didn't work correctly at first, leading to some wasted effort. # .github/workflows/deploy.yml (Excerpt from initial version) - name : Run Preload Detection run : | # ... existing logic ... if [[ "$LINE" == *"some_pattern"* ]]; then echo "Preload detected" # ... fi I modified it to detect only specific lines like the above, which led to unintended behavior. // next.config.js (Initial configuration) module . exports = { // ... experimental : { // ... }, // ... }; Regarding extensions, I initially allowed only a few types, and only after experiencing chat build failures did I modify it to support more extensions. Root Causes In the end, it was a combination of several complex issues. There were flaws in the --preload detection logic, and the range of supported extensions in the next.config file was too narrow, which was the direct cause of the chat build failures. Additionally, there was confusion arising from the chat server builds being inconsistent between P1/P2 and P0 stages. Problems also occurred because the .next directory was not preserved, and the smoke gate was too lenient, failing to catch build failures. Finally, there was an unexpected side effect where the next/font/google library caused GCE outbound connection errors. Solutions To address these

What I Built I'm thrilled to present Chrono Shift: Time Weaver – a time-bending puzzle platformer that challenges players to manipulate time itself to overcome obstacles and solve environmental puzzles. The Concept Imagine being able to see two versions of the same level simultaneously – the past and the present. In Chrono Shift, you don't just play through a level once; you play through it twice, switching between timelines to create pathways that wouldn't exist in either timeline alone. A bridge that collapsed in the present might be intact in the past. A door that's locked now might be open in the past. By strategically shifting between eras, you create a path forward that exists only through your mastery of time. What Makes It Special Dual-Timeline Mechanics : Switch between past and present with the press of a button, watching as the world transforms around you 10 Unique Levels : Each level introduces new mechanics and challenges, gradually building your time-weaving skills Pixel Art Beauty : Vibrant, hand-crafted pixel art with parallax scrolling backgrounds that bring each era to life Collectible Time Crystals : Find hidden crystals in each level to unlock challenges and achievements Responsive Controls : Smooth platforming with jump, dash, and time-shift abilities that feel tight and satisfying Ambient Soundtrack : Era-reactive music that shifts with your timeline changes, immersing you deeper in the experience Mobile-Friendly : Touch controls mean you can weave time on any device The Journey This game was born from a simple question: what if platformers could teach us about perspective? By forcing players to see the same space from two different temporal viewpoints, Chrono Shift becomes more than just a game – it's a meditation on how our choices in the past shape our present, and how understanding both can unlock possibilities we never saw before. Play it here: https://lovable.dev/projects/bcaa0de3-f14c-4bad-9616-405c896d19bc Video Demo While there's no vi

Search results look simple from the outside. You type a keyword into Google, Bing, or another search engine, and you get a page of links, snippets, ads, maps, news, images, videos, and sometimes AI-generated answers. But if you have ever tried to collect search results at scale, you know it gets messy quickly. A result page is not just a list of links. It changes by country, language, device, location, query intent, and search engine. The same keyword can show different rankings in New York, London, Singapore, or Berlin. A page may include organic results, paid ads, local packs, shopping results, People Also Ask, news results, images, videos, or other SERP features. For humans, that is just a search page. For SEO teams, AI teams, data teams, and developers, it is a data source. That is where a SERP API becomes useful. What is a SERP API? SERP stands for Search Engine Results Page . A SERP API is an API that lets you collect search engine results in a structured format, usually JSON and sometimes HTML. Instead of manually searching a keyword or building a scraper to parse search result pages, you send a request to a SERP API with parameters such as: keyword search engine country language location device type output format The API then returns structured search data. A simplified response might look like this: { "query" : "best project management software" , "organic_results" : [ { "position" : 1 , "title" : "Best Project Management Software Tools" , "link" : "https://example.com" , "snippet" : "Compare features, pricing, and reviews..." } ] } This is much easier to work with than raw HTML. You can store it in a database, send it to a dashboard, compare rankings over time, feed it into an AI workflow, or generate automated reports. Why not just scrape search results yourself? You can build your own scraper. For a small test, that may be enough. You can send a request, parse the HTML, extract titles and links, and save the data. The problem starts when the workflow bec

Modern applications depend on secrets. Every application requires: Database Passwords API Keys SSH Keys TLS Certificates Cloud Credentials OAuth Tokens Service Account Keys The biggest question is: Where should we store them securely? Unfortunately many organizations still store secrets in: Git Repository Docker Image Application Config Files Environment Variables Shared Documents Excel Sheets This creates a massive security risk. This is why Secret Management platforms like HashiCorp Vault became critical in modern cloud-native environments. 🔗 Resources ** Support the Journey on GitHub: If you're following along, consider starring and forking the repo:** https://github.com/17J/30-Days-Cloud-DevSecOps-Journey What is a Secret? A secret is any sensitive piece of information used to authenticate or authorize access. Examples: Database Password AWS Access Key JWT Signing Key API Token TLS Certificate Private Key OAuth Secret If a secret gets exposed: Attacker ↓ Application Access ↓ Database Access ↓ Infrastructure Compromise What is Secrets Management? Secrets Management is the process of: Store Protect Rotate Control Audit sensitive credentials securely. A modern secrets management platform provides: Centralized storage Encryption Access control Secret rotation Audit logs Dynamic credentials Why Secrets Management Matters Imagine this scenario: database : username : admin password : Password123 committed into GitHub. Result: Developer Pushes Code ↓ GitHub Repository ↓ Credential Leak ↓ Database Breach This happens more often than people realize. The Problem with Traditional Secret Storage Many teams use: .env Files Kubernetes Secrets Configuration Files Hardcoded Passwords Problems: Difficult rotation No audit trail Poor access control Risk of accidental exposure Compliance failures What is HashiCorp Vault? HashiCorp Vault is a centralized secrets management platform designed to securely store, access, and manage secrets. Think of Vault as: Central Secret Bank for you

I've been building a content production tool for my company, which uses AI for things like structure and automatically inserting links with defined anchor text. 2 days ago, I started testing the results in AI text detection scanners and kept getting inconsistent results, even when I knew my articles looked more natural than a previous test. Revision after revision of code, 10 hours spent trying to get it right. And then I decided to pop in a few articles I had personally written, where I knew AI was not involved. Not a single one of the major scanners got it correct. Most of them flagged my original content as having more AI text than the articles my tool was producing. Now that I've gone down this rabbit hole and understand how AI writes and how the detectors work, I'm not sure that any tool is ever going to be able to do this correctly. For obviously written AI articles, sure, it will catch those. But for original content, I just don't see how it's ever going to work. What is everyone's thoughts on this? Has anyone done the same experiment? submitted by /u/Sypheix [link] [留言]

Hi all, Lately I have been working on creating a package for Multi Agent RL based drone environments with different objectives, all bundled into a single GitHub repository: tau-intelligence/MuJoCo-drones-gym. I am currently trying to organize things for RL community people, with a couple more tools coming soon. But right now, I want to make it useful for the community and hence would love some feedback from different people, about how I could improve it, incorporate more things into it or fix some broken implementation. Also everyone is welcome to raise issues on the repo. Thank you for the support. PS: I have some research publications at RL and ML venues regarding work on RL, though I still want to consider myself as a student of the field and hence would love your help here. submitted by /u/MT1699 [link] [留言]

Table of Contents The Integration Problem That Broke Industry 4.0 MCP: The Vertical Connection Layer How MCP Connects to Servers, Tools, and Databases MCP in Real World Industrial Automation ACP: The Horizontal Communication Layer How ACP Works Under the Hood ACP in Real World Industrial Coordination The Six Precise Differences How They Work Together: The Complete Stack Decision Framework for Industrial AI Architects 1. The Integration Problem That Broke Industry 4.0 Industry 4.0 promised connected factories, intelligent automation, and seamless data flow between machines, systems, and humans. The technology arrived. The connectivity did not. The reason is a number called N times M. An enterprise manufacturing facility might have 12 AI agents across quality, maintenance, and planning — and 28 data sources including ERP, MES, SCADA, IoT sensors, databases, CAD repositories, and supplier APIs. Without a standard protocol: 12 agents multiplied by 28 data sources equals 336 custom integrations. Each integration is bespoke code. Each breaks when either side updates. Each requires maintenance. Each represents a point of failure and a security surface that must be independently managed. IBM VP Armand Ruiz stated this precisely: "Without a common standard, every integration is costly duct tape." MCP and ACP together replace 336 pieces of duct tape with two standard protocols — one governing how agents connect to systems, one governing how agents connect to each other. The smart manufacturing market is projected to reach 374 billion dollars by 2025 at 11.8 percent CAGR. Over 50 percent of companies in industrial automation are expected to adopt MCP-based connectivity. The integration problem is not theoretical. The solution is being deployed at scale right now. 2. MCP: The Vertical Connection Layer MCP connects agents to tools and data — the vertical integration layer. It handles the connection between an AI agent and everything it needs to interact with in the external worl

1. update WSL environment sudo apt update && sudo apt upgrade -y 2. install dependencies If you don't use -hf option, you don't need to install libssl-dev in this step. sudo apt install build-essential cmake git libssl-dev -y If nvidia-smi shows a GPU/GPUs on your terminal, you will need to install the tooklit. This will take some time. sudo apt install nvidia-cuda-toolkit -y 3. clone the repo Build llama-cli and llama-server. This step also will take some time. If you don't plan to use -hf option, you don't need to use -DLLAMA_OPENSSL=ON . git clone https://github.com/ggerganov/llama.cpp cd llama.cpp cmake -B build -DGGML_CUDA = ON -DLLAMA_OPENSSL = ON cmake --build build --config Release # no GPU git clone https://github.com/ggerganov/llama.cpp cd llama.cpp cmake -B build cmake --build build --config Release 4. run the model Run gemma-4-12b-it with cli and server. unsloth/gemma-4-12b-it-GGUF · Hugging Face We’re on a journey to advance and democratize artificial intelligence through open source and open science. huggingface.co ./build/bin/llama-cli -hf unsloth/gemma-4-12b-it-GGUF:UD-Q4_K_XL > hello [ Start thinking] The user said "hello" . The user is initiating a conversation. Respond politely and offer assistance. * "Hello! How can I help you today?" * "Hi there! What's on your mind?" * "Hello! Is there anything I can assist you with?" [ End thinking] Hello! How can I help you today? [ Prompt: 19.5 t/s | Generation: 11.8 t/s ] or run web-ui ./build/bin/llama-server -hf unsloth/gemma-4-12b-it-GGUF:UD-Q4_K_XL --port 8080 optional download model from huggingface mkdir -p models wget -O models/gemma-4-12b-it-UD-Q4_K_XL.gguf https://huggingface.co/unsloth/gemma-4-12b-it-GGUF/resolve/main/gemma-4-12b-it-UD-Q4_K_XL.gguf

This is the third and final part of my first React project for the Frontend Mentor's Digital Bank Landing Page Challenge . I'm excited to say that I finally finished it. Live Demo: https://bank-landing-page-react-gmtz.vercel.app/ Github Repo: https://github.com/ayra-baet/bank-landing-page-react Learning Component Reusability Beyond Small Elements At first, I thought this final part would mostly involve finishing the Articles and Footer. But while building, I realized something more important: React's reusability isn't limited to small UI elements like buttons or cards; entire sections can be reusable too. Earlier in this project, I reused a single Button component across the header, hero, and footer. This time, I noticed that the Features and Articles sections shared almost the same structure: both had an h2 heading both used a grid layout both wrapped child components The only real difference was that the Features section included a description paragraph. That immediately felt like a perfect use case for a reusable component with conditional rendering. So I created a reusable Section component: function Section ({ backgroundColor , title , description , children }) { return ( < section className = { backgroundColor } aria-labelledby = { ` ${ title } -heading` } > < div className = "container section__container" > < div className = "section__header" > < h2 id = { ` ${ title } -heading` } > { title } </ h2 > { description && < p > { description } </ p > } </ div > < div className = "section__grid" > { children } </ div > </ div > </ section > ); } Then I reused it inside my LandingPage component: function LandingPage () { return ( <> { /* other LandingPage JSX */ } < section id = "features" > < Section backgroundColor = "section--gray-100" title = "Why choose Digitalbank?" description = "We leverage Open Banking to turn your bank account into your financial hub. Control your finances like never before." > < Features /> </ Section > </ section > < section id = "articl

TL;DR — The DIFP protocol was designed to be data-compact and geo-aware from day one. We recently discovered it maps almost perfectly onto the Nostr event format. Here's how, and why it matters for decentralized food infrastructure. Background: What Is DIFP? DIFP (Djowda Interconnected Food Protocol) is an open protocol designed to sync food product data across distributed nodes — compactly, efficiently, and with geo-location awareness built in by default. One of its core design decisions is the PAD system (Preloaded Asset Distribution): Apps ship with a preloaded asset pack — item metadata, compressed images, category structure — all bundled at install time. Only price and availability need to travel over the wire during sync. This means the data footprint per product is tiny. Very tiny. Enter Nostr Nostr is a simple, open protocol for decentralized communication. One of its key specs: events support up to 64 KB of content . When we started exploring Nostr as a potential transport layer, we ran the numbers — and the fit was surprisingly clean. The Math: Products Per Event Baseline encoding A product represented with three fields: { "id" : 500 , "available" : true , "price" : 30000 } At this level of verbosity, a single 64 KB Nostr event can hold approximately: ~1,500 – 2,000 products Already useful. But we can do better. Optimized encoding Two key optimizations: 1. Drop the availability key — If a product entry exists in the JSON, it's available. If it's absent, it's not. No boolean needed. 2. Drop the field names — Instead of {"id": 500, "price": 30000} , just store: 500,30000 Field mapping is handled at the app level, not the protocol level. The device knows position 0 is the product ID, position 1 is the price (in smallest currency unit, e.g. cents). Result ~6,000 – 7,000 products per single Nostr event Possibly more, depending on the price distribution and ID ranges in a given catalog. Geo-Discovery: MinMax99 Cells DIFP uses a geo-cell system called MinMax99 to

Or: how a "this host is dead" verdict from a single net.LookupHost call quietly broke our crawler, and what we did about it. The setup We run a crawler that fetches tens of thousands of corporate websites a day from a datacenter. Before we spend any budget on a fetch — the actual HTTP request, the residential proxy hop, the S3 upload — we run a cheap reachability gate . The job of the gate is one thing: answer the question "is it even worth trying to fetch this host from here?" The first version of that gate was the obvious thing: resolve the host. If DNS returns an IP, the host exists. If it doesn't, mark the URL dead and move on. That gate was wrong often enough to matter. This is the story of the four ways it was wrong, and the gate we ended up with. Why "just resolve the host" isn't enough A naive reachability check has the shape: Call net.LookupHost . If it returns IPs, the host is reachable. If it errors, it isn't. Every clause in that sentence is a lie in production. Here are the four leaks we hit, in order of how painful they were. Leak 1 — CNAME chains the resolver doesn't finish in time A lot of corporate sites don't resolve directly. They sit behind a CDN, which sits behind a tenant-specific alias, which sits behind a regional load-balancer name. From DNS's point of view, that's a CNAME chain: ir.bigcorp.com → bigcorp.cdnvendor.net → edge-eu-west-3.cdnvendor.net → A 203.0.113.42 LookupHost is supposed to chase the chain transparently and hand you the final IP. It usually does. But "usually" hides two real failure modes: The resolver chases the chain in series under a single deadline. A slow hop two-thirds of the way down eats the whole budget; the call returns a timeout, not the IP it would have found with another 200ms. An intermediate hop misbehaves — wrong record type, NXDOMAIN at a tier the resolver doesn't expect, a stub that's been decommissioned. The lookup fails even though the host is registered and reachable through other paths . Both look ident

I've been frustrated with SQL learning resources for a while. Most are either: Dry reference docs Toy exercises with no context ("SELECT * FROM employees") Paid platforms with paywalls after level 3 So I built SQLwak — a free, browser-based SQL game where you're hired as a Graduate Analyst at Lion City Bank , a fictional Singapore bank. How it works Instead of abstract exercises, every challenge is a real business request from a colleague: "The Operations team needs all Central region branches for an upcoming audit." "Risk wants customers with credit scores below 600 who have active loans." "Finance needs vessels ranked by cargo revenue — use window functions." You write actual SQL against a realistic 9-table banking database and get immediate feedback. 57 levels across 4 tiers Tier Skills 🟢 Foundational SELECT, WHERE, ORDER BY, LIMIT 🟡 Intermediate JOINs, GROUP BY, HAVING, subqueries 🔴 Advanced CTEs, multi-table aggregations ⚫ Expert Window functions (RANK/DENSE_RANK OVER PARTITION BY), UNION ALL, compound CTEs The database schema Lion City Bank has two divisions: Retail Banking: customers, accounts, transactions, loans, branches, products Maritime Trade Finance (Advanced/Expert levels): vessels, cargo_shipments, trade_finance_facilities — covering voyages between Singapore, Port Klang, Bangkok, Jakarta, and Ho Chi Minh City. The maritime division exists because Singapore is a major trade hub. It makes the Expert levels genuinely interesting — you're ranking vessels by cargo revenue and analyzing trade finance utilisation rates, not just counting rows. Technical details Next.js 15 + TypeScript + Tailwind CSS SQLite via WebAssembly — all query execution is client-side, no backend needed Deployed on Vercel Fully open source: github.com/martinl5/sqlwak No signup. No download. Just SQL. Open the link and start writing queries: sqlwak.vercel.app Would love feedback on difficulty progression, new level ideas, or schema additions. What SQL concepts do you wish you'd pract

The first trillionaire in history won't make their money from banking, oil, or real estate. They'll make it from rockets and algorithms — and the implications of that distinction are genuinely unsettling. The Problem It's Solving (Or Creating) SpaceX is preparing for its IPO. Analysts tracking the raise estimate it will push Elon Musk's net worth past the trillion-dollar threshold, making him not just the richest person on Earth by a wide margin, but something qualitatively different from every billionaire before him. The standard framing treats this as a wealth story. It isn't. A billionaire is powerful because they have money. A trillionaire is powerful because, at that scale, they stop needing permission from anyone — governments, investors, boards, markets. The constraints that keep institutional power in check simply don't apply anymore. How Trillionaire-Scale Power Actually Works There's a clean way to understand the difference. A billionaire can fund political candidates, buy media, lobby aggressively. Another billionaire can fund the opposition. It's expensive, but the system has a counter. A trillionaire doesn't have a counter. They are the counter. They can simultaneously build the communications infrastructure (Starlink), the transportation layer (SpaceX), the compute stack (through xAI), and the political attention economy (via platform ownership). No single democratic institution was designed to regulate someone who owns the pipes that the institution runs on. Arnab Ray's piece in today's Times of India puts it directly: a trillionaire's thoughts and algorithms will shape planetary outcomes. That's not hyperbole. When Musk eventually lands people on Mars, the governance frameworks, the property rights, the social contracts of that colony — those will be engineered by him and his companies, not negotiated through any existing democratic process. What Societies Are Actually Unprepared For Most of the policy debate around billionaires focuses on tax rates

What Ollama actually is Ollama is an open-source runtime for large language models that runs on your own computer — Mac, Windows, or Linux. Think of it as the “Docker for LLMs”: instead of wrestling with Python environments, model weights, and GPU drivers, you type one command and a model is running. The pitch is simple: keep your data on your machine, pay nothing per token, and work offline. When you run ollama run gemma4, Ollama downloads the model, loads it into your GPU’s memory (or system RAM if you don’t have a GPU), and drops you into a chat prompt. That’s it. Behind that simplicity, Ollama is doing a lot of work for you: Model management — pulling, versioning, and storing models from its registry, the way a package manager handles software. Quantization — automatically using compressed (GGUF) versions of models so a 27-billion-parameter model fits in consumer memory. GPU layer allocation — deciding how much of the model lives on your GPU versus CPU, based on the VRAM you have. Context and KV-cache management — handling the memory that grows as a conversation gets longer. A REST API — exposing everything on http://localhost:11434 so your own apps can talk to it. How it works under the hood Ollama is not itself an inference engine. It’s an experience layer wrapped around one. Under the hood it uses llama.cpp, the C++ engine that does the actual math of running a quantized model efficiently on CPUs and GPUs. As of v0.19 (March 2026), Ollama also uses Apple’s MLX backend on Apple Silicon — a change that delivered enormous speedups (on an M5 Max running Qwen 3.5, decode throughput nearly doubled). The workflow looks like this: You run a command — ollama run qwen3 from the terminal, or a request to the API. Ollama resolves the model — if it isn’t already downloaded, it pulls the GGUF weights from the registry. It loads the model into memory — splitting layers between GPU and CPU based on available VRAM. It serves responses — either interactively in your terminal o