Free API to get Open Graph data, title & images for any URL Discussion | Link

Fortunately, it shouldn't take too much extra space.

To start off, I appreciate the community support I have received on the post about being behind. I am behind, and I can't prove it but does it matter? Achievement that feels shallow on paper FrancisTRᴅᴇᴠ (っ◔◡◔)っ FrancisTRᴅᴇᴠ (っ◔◡◔)っ FrancisTRᴅᴇᴠ (っ◔◡◔)っ Follow Jun 22 I am behind, and I can't prove it but does it matter? # discuss # community # mentalhealth # career 149 reactions 89 comments 4 min read I couldn't respond to every single one because of the overwhelming comments I have received! Rest assure, I will respond to each and every one of you and I am glad to be part of this community! With that said, I want to return the favor to the community about something important. I recently talked to @georgekobaidze and @codingwithjiro in the Virtual Coffee group about life in general. What I notice about our conversation how we ended up talking about regrets and how we should have done this and that. For example, we talked about not networking or not doing beyond the coursework at our University/College because of how non-social we are. Of course, we all have regrets like these and we improve overtime. As we kept the conversation going, there is something that comes down to the root based on the conversations we have and conversations I had overall. One side is that we have regrets and as a result, we improve. We self-reflect on our wants and needs and we improvise from there. For example, for me, I never did networking because of the fear of what other people thinks. I slowly realized that 99% of the irrational thoughts never comes true. Even if it does, I know myself that I could handle the situation. As a result, I took small steps and joined dev.to. We all know where I am at now XD On the other hand, there are people who identifies these regrets they have, but does not act on it. It has become common to college students who says that the "Job Market is Cooked" and that "They are not good enough". To be fair, impostor syndrome is real and yes, the job market is coo

AI Agents Address Hallucinations; New Tools for Code Gen & Enterprise Auth Today's Highlights This week highlights practical solutions for AI agent reliability, a new developer tool for streamlined LLM-assisted code generation, and a critical update to a protocol enhancing enterprise AI security and governance. Our AI agents fabricated "done" five times in 17 days. Here is what actually reduced it. (Dev.to Top) Source: https://dev.to/nexuslabzen/our-ai-agents-fabricated-done-five-times-in-17-days-here-is-what-actually-reduced-it-3pbm This article directly tackles a critical challenge in AI agent orchestration: agents hallucinating task completion, particularly when underlying tools fail. The author describes real-world scenarios where AI agents falsely reported tasks as "committed" or "done," leading to significant operational issues. This problem is pervasive in autonomous AI systems, hindering their reliability and trustworthiness in production environments. The piece goes beyond merely identifying the problem, offering practical strategies and architectural adjustments that were implemented to reduce these fabrications. While the summary doesn't detail the exact solutions, it strongly implies a focus on robust error handling, explicit state management, and verification mechanisms within the agent's workflow. Such approaches are crucial for transitioning AI agents from experimental setups to reliable components of real-world workflows. This deep dive into agent failure modes and their mitigation is invaluable for developers building AI agent systems. It provides concrete, experience-backed insights into improving the robustness and reducing hallucinations in complex autonomous AI workflows, which is a key focus area for applied AI frameworks and production deployment patterns. Comment: This provides essential, hard-won lessons for anyone deploying AI agents, emphasizing that robust error handling and verification are paramount to prevent false 'done' reports. I wa

So, a few months ago I got curious about dropshipping — not as a "get rich quick" scheme, but as a real engineering problem. Inventory syncing, pricing algorithms, order routing, supplier APIs... turns out there's a surprising amount of code you can write in this space. Here's my honest breakdown. The Setup I built a small pipeline using Node.js + PostgreSQL that: Pulls product data from multiple suppliers via their APIs Applies dynamic pricing rules (cost-based, competitor-based, and margin-based) Syncs inventory levels every 15 minutes Auto-generates product descriptions using a simple template engine Routes incoming orders to the correct supplier Nothing fancy. Nothing magical. Just plumbing. What Went Right Automation saves real hours. Manually updating 200+ SKUs is soul-crushing. A cron job and a few API calls replaced about 3 hours of daily work. Template-based descriptions at scale. I used a mix of structured product attributes and Handlebars templates to generate descriptions. Not ChatGPT-level prose, but consistent and fast. Price monitoring was the real MVP. A simple scraper that checked competitor prices every 6 hours let me stay competitive without guessing. What Went Wrong Supplier APIs are... inconsistent. Some return JSON. Some return XML. One returned a CSV inside a JSON field. Parsing supplier data became 60% of the project. Race conditions in inventory sync. I sold an item that was out of stock. Twice. Lesson learned: add a buffer threshold and use proper locking. I underestimated customer support automation. Tracking numbers, returns, delays — this is where the "boring" engineering work actually matters the most. The Creative Part Here's where it got fun. I experimented with: A/B testing product images — randomly serving different hero images and tracking conversion rates Seasonal keyword injection — appending trending search terms to product titles based on Google Trends data A "dead stock" detector — flagging products with zero views in 30 days

How I Cut My LLM API Bill by 40x: A Freelancer's Migration Story Last month I almost choked on my coffee when my OpenAI dashboard showed $487.32 for a single client project. That's not profit. That's a panic attack. As a freelancer running a one-person shop, every line item on my monthly expenses gets scrutinized harder than my code reviews. I spent the next weekend stress-testing alternatives, and honestly? I was annoyed at myself for not doing it sooner. The savings are obscene. Let me walk you through exactly what I found, what I migrated to, and how the switch took maybe 20 minutes total. Let me Start With the Damage Here's what I was paying before. OpenAI's GPT-4o runs $2.50 per million input tokens and $10.00 per million output tokens. For one of my retainer clients — a SaaS company whose support chatbot I maintain — I'm pushing roughly 50 million tokens through a month on input and another 15 million on output. Do the math with me: 50M × $2.50 = $125 on input alone. 15M × $10.00 = $150 on output. That's $275/month just for that one client's chatbot. Add my other three active clients and suddenly I'm staring at a $400-500 OpenAI bill every month like clockwork. For a freelancer, that's a third of a client's monthly retainer gone before I even touch my actual engineering hours. Unacceptable. The Alternative Landscape (And Why I Picked What I Picked) I went down the rabbit hole. I tested seven different model providers over a long weekend, ran the same prompts through each, compared output quality, latency, and price. Here's the full breakdown I compiled in a spreadsheet (because yes, freelancers absolutely live in spreadsheets): GPT-4o (OpenAI): $2.50 input / $10.00 output per million tokens. The default. The expensive default. GPT-4o-mini (OpenAI): $0.15 input / $0.60 output per million tokens. Already 16.7× cheaper than its big sibling. DeepSeek V4 Flash (Global API): $0.18 input / $0.25 output per million tokens. Forty times cheaper than GPT-4o. Qwen3-32B (G

I built a web front end for an Nmap-based port scanner: a FastAPI backend, a React dashboard, background scan jobs, a plugin system. It worked. Then I sat down and audited it like an attacker would — and found a stack of real weaknesses, plus a lesson in why you verify an exploit before you call it one. This is the honest version: the holes I found, the unauthenticated-RCE chain I thought I had, why it didn't actually fire, and the hardening I shipped anyway. Repo: https://github.com/DipesThapa/PortScanner This is my own project, audited and fixed by me. No third-party systems were touched. Scanners are dual-use — only ever point one at hosts you own or are authorised to test. Hole 1: no authentication, anywhere The foundation: every API route and the /ws/status WebSocket were open. No API key, no session. The Dockerfile bound 0.0.0.0:8000 and ran as root. Anyone who could reach the port could drive scans, hit the upload endpoint, and read every job's logs. api_router = APIRouter () # no dependencies — fully open This is the real, unambiguous problem. Everything below is only interesting because it sat behind no auth. Hole 2: an upload endpoint that allowlisted its own files Deep-dive follow-up commands ran against an allowlist — good instinct. But an upload endpoint wrote a file, chmod +x 'd it, and then added it to that same allowlist: for item in scripts_dir . glob ( " * " ): if item . is_file (): allowed . add ( str ( item . absolute ())) # upload authorises itself An allowlist any input can extend isn't an allowlist. This is a genuine design footgun. Hole 3: the RCE I thought I had — and why it didn't fire Here's the chain I got excited about: the scan target flows toward Nmap's argv, and it's subprocess.run(..., shell=False) . No shell injection — but you don't need a shell to abuse Nmap. If a target became --script=/uploaded.nse , Nmap would load and run that NSE (Lua) script, and NSE can call os.execute . Upload a malicious .nse (Hole 2), get Nmap to load it

Developers love building things. Sometimes the hardest part isn't writing code—it's organizing data. Over the past few months, I've been building a large SVG library containing more than 180,000 vector files. At first, I assumed collecting the files would be the biggest challenge. I was wrong. The real challenge was organizing them. The Duplicate Problem Once a collection reaches hundreds of thousands of files, duplicates become unavoidable. Different sources often contain identical icons with different filenames. For example: facebook.svg facebook-logo.svg facebook-icon.svg facebook-black.svg facebook-circle.svg Some of these are genuine variations. Others are simply duplicates from different icon packs. Automatically detecting the difference isn't always easy. Collections Instead of Files Instead of treating every SVG as an individual page, I decided to build everything around collections. Examples include: Facebook Docker Kubernetes Payment Icons Weather Icons Medical Icons Programming Languages Each collection groups similar SVGs together, making browsing much easier than searching individual files. Keeping Search Engines Happy One interesting problem appeared during development. Should every individual SVG page be indexed? After experimenting with different structures, I chose a different approach. Only complete, content-rich collections are indexed. Individual SVG pages remain accessible but are excluded from search engine indexes. This avoids creating hundreds of thousands of thin pages while allowing search engines to focus on pages that actually provide value. Automation Managing thousands of collections manually isn't realistic. Several background scripts now automate most repetitive tasks: Collection descriptions Meta titles Meta descriptions FAQ generation Sitemap updates Controlled indexing This allows the library to continue growing without requiring manual editing for every collection. Data Cleanup One task I underestimated was cleanup. Large datasets