标签：#challenge

This is a submission for Frontend Challenge - Comfort Food Edition, Perfect Landing What I Built Karachi Ki Raatein ("Karachi's Nights") — a single-page love letter to the street food that keeps my city awake after dark. Instead of a restaurant or a recipe box, I built it around a real pattern from home: Karachi basically runs on an unofficial food schedule. Maghrib means chai and something fried. Bun kabab happens standing up, mid-errand. Nihari is what you sit down for after Isha. Seekh kabab shows up wherever there's smoke. And halwa puri at 3am is for the people who never went to sleep in the first place. The whole page is built around that rhythm instead of a menu. A few things I'm happy with on the frontend side: A signboard hero with a flickering neon-style headline and hand-drawn CSS/SVG steam rising from a cup — no stock photography anywhere on the page, everything is drawn. A canvas-based particle steam system that replaces the static SVG once JS is available — real particles with drift, turbulence and upward acceleration, and they physically scatter when you move your cursor through them, like waving your hand through actual steam. A live "Night Clock" that reads your real local time ( Date , your timezone, nothing hardcoded) and marks whichever stall is "in season" right now with a pulsing "you are here" badge — so the page behaves differently depending on when you actually open it. A theme built for the medium : dark ink background, ember/turmeric accent colors, a hand-lettered chalk font for the "voice" of the thela-wala mixed with a bold display face for the signage, instead of the usual cream-and-terracotta food-site look. Respects prefers-reduced-motion everywhere (falls back to a static SVG steam loop and skips the canvas sim), keyboard-focusable throughout, fully responsive. Demo Journey I wanted to avoid the obvious comfort-food landing page — cream background, terracotta accents, a hero photo of a steaming bowl. It's a solid look but I see it ev

This is a submission for Weekend Challenge: Dog Days Edition What I Built Dogs don't stay long enough. That is the entire idea behind STAY. STAY is an interactive experience about time, attention, and memory. It compresses the life of a dog into a few minutes, lets you experience the small choices that make up that life, and then gives you a way to preserve the moments that mattered. The experience begins with Milo as a puppy. You spend his life making ordinary decisions: take the walk finish some work play for a while take the photo go somewhere new stay home give him the shoe he already destroyed anyway There is no perfect route. There is no "good owner" score. Life keeps moving either way. Milo grows from puppy to young dog, adult, mature dog, and eventually senior. His behaviour changes with him. He reacts quickly when he is young. He becomes calmer as he grows. Familiar toys and places return years later. His movements slow down. And somewhere in the interface, the number of days he has left keeps falling. The thesis behind STAY is simple: You cannot give a dog more years. You can give their years more life. Eventually, Milo's life ends. There is no dramatic death animation. For the whole experience, you have learned to expect Milo to occupy part of the screen. Then that space is empty. What remains are the moments you chose to keep. Those memories can be preserved as a verifiable proof on Solana devnet. But STAY does not end with simulated Milo. After his Memory Box is complete, the experience asks one final thing: Milo's story was simulated. Yours isn't. From there, users can photograph or upload a real moment with their own dog, add a name, date, and short note, and create a cryptographic attestation for that memory. The photograph itself does not need to live on-chain. Instead, STAY hashes the image locally, creates a deterministic memory manifest, and commits the proof through a real Solana transaction. The day will still disappear. The proof that it happe

I Built a Voice-First AI Tutor for Bharat in 10 Days 🇮🇳 — Here’s My Complete Journey Over the past 10 days, I participated in the 10 Days of Voice Agents challenge hosted by Murf AI. I built Vidya Vani, an intelligent, low-latency, multi-agent voice tutor that helps users practice spoken English and Mathematics. It features dynamic LLM question generation, memory retention across sessions, live analytics, and seamless agent handoffs—all powered by the blazing-fast Murf Falcon TTS and LiveKit WebRTC. This is the full story of why I built it, the architecture that powers it, the intense roadblocks I hit, and how you can build one too! The Problem: The Education Gap in Bharat India is a country of incredible diversity, but when it comes to foundational education—specifically English literacy and Mathematics—there is a massive accessibility gap. Quality education is often concentrated in urban hubs, leaving learners in rural and semi-urban areas without access to dedicated, patient tutors for 1-on-1 practice. While there are plenty of ed-tech apps and text-based AI chatbots available, they all suffer from the same fundamental flaw for foundational learners: friction. Practicing spoken English with a text-based chatbot is intimidating. It requires spelling proficiency, typing speed, and it does absolutely nothing to help with conversational confidence or pronunciation. The Solution: We needed a voice-first approach. By leveraging voice, we entirely remove the friction of typing and screen-staring. Users simply speak to their phone or computer, making the interaction as natural, accessible, and human as talking to a real teacher. Meet Vidya Vani & Aryabhata I set out to build a 24/7 educational voice tutor for the Learning & Literacy track of the challenge. But as the days progressed, I realized a single AI prompt trying to act as a master of all subjects was prone to hallucinations and confusion. So, I split the persona into two distinct experts. Vidya Vani: The Orchestr

This is a submission for Weekend Challenge: Dog Days Edition What I Built Remember Neko the cat and those Tamagotchi desktop pets from the 90s? I rebuilt that magic for 2026 — except your pet is a golden retriever puppy powered by an LLM. PawBot is a Chrome extension + browser demo where a cute pixel puppy : 🐕 Roams your screen like a classic desktop pet 🏃 Chases your cursor when you get close 🍖 Eats anything you drop — PDFs, code files, emoji, pasted text 💬 Barks back with short, mood-aware responses via Google Gemini 😴 Falls asleep if you ignore it too long (with Zzz particles!) ❤️ Reacts to pets — click to pet, double-click to wave Feed it a .pdf and it might say "Mmm, crunchy homework!" Ignore it for 40 seconds and it curls up with sad puppy eyes. Demo Full walkthrough on YouTube: Quick try locally: git clone https://github.com/Varshithvhegde/pawbot.git cd pawbot/web python3 -m http.server 8080 # → http://localhost:8080 Or load the Chrome extension: clone the repo → ./scripts/sync-extension.sh → Load unpacked → select the extension/ folder. Code Varshithvhegde / pawbot AI desktop puppy Chrome extension — pixel pet that eats your files and barks with Google Gemini PawBot 🐾 An AI desktop puppy that lives in your browser. A Tamagotchi/Neko-style pixel pet that roams your screen, chases your cursor, eats files & emoji you drop, and barks mood-aware responses powered by Google Gemini . Built for the DEV Weekend Challenge: Dog Days Edition . Demo 🎬 Watch on YouTube · 📝 DEV submission · 🔗 GitHub Features Feature Description 🐕 Pixel puppy Full sprite animations — idle, walk, run, eat, sleep, bark, wave 🍖 Feed anything Drop files, emoji, or paste text — pup chases food then eats it 🏃 Chase mechanics Food falls from above → pup runs to it → 4-frame eat animation 💬 AI barks Google Gemini generates short mood-based responses 😴 Sleep mode Ignore pup 40s → falls asleep with Zzz particles ❤️ Pet & wave Click to pet, double-click to wave paw ⌨️ Hotkeys F throw treat · B bark ·

This is a submission for Weekend Challenge: Dog Days Edition What I Built I love dogs. There, I said it. And yet, I am also scared of them. It is a strange combination. I can happily watch dog videos for hours, admire every dog I see on the street, and still instinctively tense up when one suddenly runs towards me. A lot of that comes from a traumatic experience I had with a dog as a child. You can grow up knowing that one experience doesn't define every dog you will ever meet, but sometimes your instincts don't get the memo. While thinking about this challenge, I started wondering if the problem was partly not understanding what I was seeing . If a dog is wagging its tail, what does that actually mean? If it is staring at me, should I move away? If it is barking, is it excited, nervous, protective, or something else? And if a dog is approaching me on a footpath, what should I actually do? That question became Pawsitive . Pawsitive is an interactive learning app for people who feel nervous around dogs. Instead of telling people not to be afraid, it tries to make encounters feel less unpredictable by teaching them how to recognise common body-language signals, understand situations, and make calmer decisions. But then I realised there was another side to the interaction. A dog owner might see their dog happily walking towards someone and think: "Don't worry, he's friendly!" The person approaching might be thinking: "Please don't let that dog come any closer." Both people can be looking at the same dog while experiencing completely different situations. So Pawsitive has two learning paths: people who are nervous around dogs and dog owners . The first helps people understand dogs and build confidence. The second helps owners recognise when someone might be uncomfortable, why giving people space matters, and why "my dog is friendly" doesn't necessarily make an approaching dog less intimidating. That became the idea behind the whole app: Two perspectives. One better inte

From a Simple Voice Conversation to a Multi-Capability Healthcare Voice Agent Over the past 10 days, I had the opportunity to participate in 10 Days of Voice Agents — VoiceForBharat Edition , a challenge focused on learning how to build practical, real-world voice AI agents. Instead of treating the challenge as just a series of coding tasks, I wanted to build something around a problem that genuinely matters: making healthcare access more conversational and accessible through voice. That idea became AarogyaMitra — a voice-first healthcare access assistant designed to interact with users naturally, provide useful assistance, use tools when required, remember relevant user context, and involve humans or specialist agents when the situation requires it. This article documents my journey, the architecture behind the project, the important features I built, the challenges I faced, and what I learned while developing a real-time voice AI system. What is AarogyaMitra? AarogyaMitra is a voice AI assistant focused on the Health Access track of the VoiceForBharat challenge. The goal is simple: Make healthcare assistance more accessible through natural voice conversations. Many digital healthcare experiences assume that users are comfortable reading, typing, navigating menus, and interacting with conventional applications. Voice can provide a more natural alternative. Instead of searching through menus or typing a question, a user can simply speak to the assistant and have a conversation. AarogyaMitra is designed around this idea. The core objectives are: Make healthcare-related interactions more conversational Provide a simple voice-first interface Use AI tools when additional information or actions are required Maintain useful context during conversations Follow safety-oriented guardrails Escalate situations that require human assistance Route specialized requests to a specialist agent AarogyaMitra is intended to assist users, not replace qualified healthcare professionals .

What I Built Overview & Purpose Canine AI Whisperer is an intelligent multimodal veterinary ethology and behavioral intelligence platform designed to bridge the communication gap between dogs and their humans. Our core goal is to transform modern canine care by translating subtle physical micro-signals, acoustic vocalizations, and behavioral telemetry into actionable, real-time guidance—preventing behavioral escalation and strengthening the bond between pet parents and their dogs. Key Capabilities & Architecture Multimodal Visual Posture Decoder (Gemini Vision AI) Analyzes real-time camera streams or uploaded photos to detect subtle body language cues (ear carriage, commissure tension, tail angles, pupil dilation, and weight distribution). Generates instantaneous ethological diagnoses, arousal scores (0–100), and step-by-step de-escalation action plans. Acoustic Bark Spectrogram & Translation Captures live canine vocalizations to extract fundamental frequency harmonics (Hz), sound pressure intensity (dB), and temporal cadence. Accurately classifies barks, whines, growls, and howls into emotional motivations (e.g., territorial alert, separation distress, predatory excitement) with human-language translations. Canine Voice Synthesis (ElevenLabs Neural Audio) Gives dogs their own distinctive "inner voice" based on tailored ethological personas (e.g., The Hyperactive Herder, The Philosophical Frenchie, The Regal Retriever). Generates spoken translations and calming vocal cues using custom neural text-to-speech. Ultrasonic Whistle & Restorative Sound Studio Features a Web Audio tone generator capable of transmitting silent ultrasonic frequencies (up to 22,000+ Hz) for immediate recall and attention redirection without human disruption. Includes restorative harmonic frequencies (432Hz delta calm, 396Hz distress release, and 60 BPM maternal heartbeat loops) for crate conditioning and thunderstorm anxiety. Snowflake Data Cloud & Cortex ML Analytics Simulates an enterprise-g

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

This is a submission for Frontend Challenge - Comfort Food Edition Perfect Landing. What I...

This is a submission for Frontend Challenge - Comfort Food Edition, Perfect Landing What I...

This is a submission for Weekend Challenge: Dog Days Edition What I Built Three months after adopting my rescue, I noticed he was sleeping more and eating slower. I thought he was "settling in." Six months later, the vet told me he had Stage 3 arthritis. Completely treatable if caught early. I'm not alone. 60% of serious health issues in dogs are discovered after symptoms become severe. Owners spend $653 on average at emergency vets for things that were either totally normal or should have been caught weeks earlier. And 59% of dogs in the US are overweight without their owners realizing. PawWise is an AI vet friend that gives dog owners what they actually need: instant clarity. Upload a photo of your dog and get: Health Check : Body condition score, coat health, posture analysis, breed-specific risks Behavior Decoder : "Why is my dog doing this?" with breed context and training steps Emergency Triage : Is this an emergency? Green/Yellow/Orange/Red urgency with first aid Dog Court (fun mode): Your healthy dog committed a crime? AI generates a voice-acted courtroom drama The serious modes solve real problems. The fun mode gives you something to share when everything is fine. Demo simplynadaf.github.io Try it live: simplynadaf.github.io/dog-court Upload any photo of your dog. The AI will analyze it and give you a full health report with actionable next steps, spoken aloud in a calm voice. In Dog Court mode, upload evidence of your dog's "crime" (chewed shoes, stolen food, destroyed pillows) and listen to a full multi-voice courtroom drama where your dog gets legal representation. Code simplynadaf / dog-court 🏛️ Your dog committed a crime. AI gives them a fair trial. Built with Google Gemini + ElevenLabs for DEV Weekend Challenge: Dog Days Edition 🐾 PawWise AI That Actually Understands Your Dog 59% of dogs are obese and their owners don't know. 60% of serious health issues are caught too late. I built an AI that catches it in a photo. Live Site → • Watch Demo → • Read A

La Abuela — Comfort Food from Madrid 🍲 A cozy, fully accessible landing page for an imaginary family restaurant in Madrid, built from scratch with vanilla HTML, CSS and JavaScript for the DEV Frontend Challenge: Comfort Food Edition. 🔗 Live demo: https://laabuela.bmops.tech 💻 Interactive pen (CodePen): The story La Abuela ("the grandmother") is a tiny four-table restaurant in Lavapiés, Madrid. In 1987, Abuela Carmen opened it with one rule: if it wouldn't be served at her Sunday table, it wouldn't be served here. Forty years later, the menu still has three dishes — caldo, croquetas, lentejas — and the pot still simmers for three hours. The page tells that story through a warm terracotta-and-cream palette and five illustrations drawn entirely in pure CSS — no images, no SVG, no canvas. What I built Hero — a clay pot in pure CSS: gradient body with layered inset shadows for volume, decorative band, handles, a two-tongued fire with a glowing core, a wooden table with grain, a light sweep across the heading, and animated organic steam Our story — a bowl of caldo with a wooden spoon and a terracotta heart, all divs and box-shadows The menu — three dish cards, each with its own pure-CSS illustration: a steaming bowl of caldo, three golden croquetas with crispy texture and a pool of salsa, and a dark bowl of lentils with nine individual grains The recipe — an accessible accordion unlocking Abuela's caldo, step by step Quotes — from regulars (including one from Osaka who cried into the caldo) Booking form — with inline validation, clear labels and a friendly confirmation Footer — hours, address, and a wink to Carmen The art is pure CSS — no images, no SVG Every illustration is built the way : nested absolutely-positioned divs, layered box-shadow (inset shadows give the clay its volume and the croquettes their crust), organic border-radius , and radial gradients for light. The pot alone uses four shadow layers to feel round instead of flat. The steam is animated with pure CS

This is a submission for DEV's Summer Bug Smash: Clear the Lineup powered by Sentry . The bug When you call @google/genai in streaming mode and the model asks to run a tool, Sentry's JavaScript SDK records that tool call to the span twice. One tool call in, two entries out. The attribute that carries them is gen_ai.response.tool_calls . It should hold one object per call. For a single streamed controlLight call it held two. Worse, the two did not even agree on their shape. Here is a real capture, which I come back to at the end: [ { "id" : "call_2079699" , "args" :{ "colorTemperature" : "warm" , "brightness" : 30 }, "name" : "controlLight" }, { "type" : "function" , "id" : "call_2079699" , "name" : "controlLight" , "arguments" :{ "colorTemperature" : "warm" , "brightness" : 30 }} ] Same id, same call, listed twice. One entry keys the parameters under args , the other under arguments . Anything reading this later sees two tool invocations where the model made one. Following the value The streaming instrumentation lives in packages/server-utils/src/ai/google-genai/streaming.ts . Every chunk of the stream runs through handleCandidateContent . That function wrote tool calls from two places: function handleCandidateContent ( chunk , state , recordOutputs ) { if ( Array . isArray ( chunk . functionCalls )) { state . toolCalls . push (... chunk . functionCalls ); // push #1 } for ( const candidate of chunk . candidates ?? []) { // ...finish reasons... for ( const part of candidate ?. content ?. parts ?? []) { if ( recordOutputs && part . text ) state . responseTexts . push ( part . text ); if ( part . functionCall ) { state . toolCalls . push ({ // push #2 type : ' function ' , id : part . functionCall . id , name : part . functionCall . name , arguments : part . functionCall . args , }); } } } } Push #1 spreads chunk.functionCalls into the accumulator. Push #2 walks candidate.content.parts and pushes every functionCall it finds. They look like two different sources. They

Quand on m’a appelé, l’attaque durait depuis environ une semaine. Elle visait la page de connexion d’une application historique qui générait son HTML côté serveur. Les requêtes se comptaient en millions et provenaient d’un très grand nombre d’adresses IP, ce qui rendait un blocage par IP peu efficace. Contrairement à d’autres campagnes que j’avais rencontrées, l’assaillant faisait également tourner ses empreintes JA3 et JA4. Même un rate limiting agrégé sur ces signaux ne pouvait donc apporter qu’une réponse partielle. Quelques jours plus tard, une attaque similaire a visé une deuxième application chez mon client. Cette fois, il ne s’agissait plus de l’ancienne application server-side, mais d’une SPA (single page app) qui appelait une API JSON pour créer les comptes. Ces deux incidents m’ont permis d’utiliser les deux modes d’intégration de la fonctionnalité Challenge d’AWS WAF : le challenge directement renvoyé par le WAF pour une page HTML ; le challenge résolu en amont par challenge.js , puis transmis à une API appelée avec fetch . Pourquoi placer le challenge côté infrastructure ? Si mon client m'a appelé au bout de 7 jours, c'est que l'équipe a d'abord essayé de traiter l'attaque au niveau applicatif, via l'intégration de Cloudflare Turnstile. L’intégration était sérieuse. Un module PrestaShop gérait les clés, l’activation globale et des configurations distinctes selon le tenant. Lors de la soumission, l’application récupérait le jeton du formulaire et le validait elle-même auprès de Cloudflare : $turnstileToken = Tools :: getValue ( 'cf-turnstile-response' ); if ( empty ( $turnstileToken )) { $turnstileValid = false ; } elseif ( ! $this -> verifyTurnstileToken ( $turnstileToken )) { $turnstileValid = false ; } La validation nécessitait ensuite un appel serveur vers siteverify : $response = Tools :: file_get_contents ( 'https://challenges.cloudflare.com/turnstile/v0/siteverify' , false , stream_context_create ([ 'http' => [ 'method' => 'POST' , 'header' => 'Con

This is a submission for DEV's Summer Bug Smash: Smash Stories powered by Sentry . Background I was building a Coding Activity Tracker to give me realistic timing for how long I actually spend coding — typing, reading, debugging, idle, everything. For that to work, it needed to know when Visual Studio was debugging anything , because breakpoints completely change how an app behaves. Running the tracker standalone meant it had to detect external debugging sessions. Debugger.IsAttached only detects debugging of the current process , so standalone mode always reported “no debugger,” even when Visual Studio was actively debugging another project. That single limitation broke the entire purpose of the tracker. The tracker had to detect debugging even when it wasn’t the app being debugged . What Was Tried Once it became obvious that Debugger.IsAttached was useless for standalone mode, I started trying every simple, reasonable approach that should have worked but didn’t. Parent‑process tracing int parentPid = GetParentProcessId(targetProcess); Fails because Visual Studio doesn’t always launch the debug target. Sometimes the user launches it manually. Sometimes VS attaches to an already‑running process. WMI queries var query = new ManagementObjectSearcher("SELECT * FROM Win32_Process WHERE ProcessId = " + pid); Slow, stale, inconsistent, and occasionally wrong. Not usable in real‑time tracking. Process‑tree walking var children = GetChildProcesses(vsProcess.Id); Visual Studio’s process tree is chaos. Helper processes spawn and die constantly. None reliably indicate debugging. Handle inspection var handles = GetProcessHandles(targetProcess); There is no stable “debugging handle” pattern. Different projects produce different handle sets. Thread‑freeze detection bool frozen = targetProcess.Threads.Cast<ProcessThread>() .Any(t => t.ThreadState == ThreadState.Wait); Breakpoints freeze the debugger, not the tracker. And threads freeze for normal reasons too. Tons of false positiv

We're back with another DEV Weekend Challenge, a short bite-sized challenge planned to fit into your...

This is a submission for Frontend Challenge - Comfort Food Edition, CSS Art. ...

This is a submission for DEV's Summer Bug Smash: Smash Stories powered by Sentry . You Know What's Worse Than Not Being Able to Log In? Being told everything worked right up until you try to actually use your account. Yes, that was a real bug. And, somehow, I ended up being pulled into another authentication mystery. At this point, I’m starting to think authentication bugs have a personal grudge against me. 😅 In my previous Smash Story , I wrote about a bug where users simply couldn't log in. This time, the problem was sneakier because most of the flow looked completely healthy. The user was approved, the background task ran, the email and SMS arrived, and Cognito had a user. Then the user actually tried to use their account. And everything fell apart. It Started With Two User Pools The authentication setup was fairly large and had evolved over time, so there wasn't one shiny User Pool doing everything. We had an older Cognito User Pool supporting existing authentication flows, including mobile-based signup, while a newer User Pool handled a newer flow where users received an email containing their PIN. Both pools were intentional because they supported different parts of the authentication journey. That wasn't the problem. The interesting part was that the application database had its own representation of a user, while Cognito had another. On top of that, some of the work connecting those two systems happened asynchronously. As long as everyone agreed about who the user was, nobody cared. The moment they disagreed, authentication became very interested. The Tiny Timing Window The problem appeared in the partner and dependant journey. A member could create a partner or dependant during signup or later from the member details area. A relevant non-member user would then approve the account, which scheduled an asynchronous task called SendingEmailsAfterApprovalBot in a TaskList database table. That task ran every 15 minutes, and once it executed, the partner or depend

This is a submission for Frontend Challenge - Comfort Food Edition, CSS Art. ...

DASTAN — The Taste of Home 🍲 This is my submission for the Frontend Challenge – Comfort Food Edition, Perfect Landing. What I Built For this challenge, I wanted to create something that felt more like a story than a typical food website. That idea became DASTAN — The Taste of Home . “Dastan” means a story, and the concept behind the project is simple: food is rarely just food. A dish can remind us of a person, a place, a family gathering, or a moment we haven't thought about in years. DASTAN is a visual, editorial-style landing page that explores comfort food from different parts of the world through photography, cultural stories, ingredients, and the people behind the memories. The goal was to make the experience feel warm, premium, and personal from the moment someone opens the page. The Idea The line that shaped the whole design was: Every culture has a taste of home. I wanted the website to communicate that feeling without relying on a traditional recipe-blog layout. Instead, I treated each dish almost like a magazine story. You can discover dishes from different regions, read the story behind them, and explore how food connects people across cultures. The Design I went for an editorial-inspired visual direction rather than a conventional modern dashboard. The design uses: Warm cream backgrounds Deep charcoal sections Muted gold accents Large serif typography Editorial-style food photography Rounded cards Generous spacing Strong visual hierarchy Story-focused content Subtle borders and details I wanted the interface to feel like opening a beautifully designed food magazine. At the same time, I made sure the experience remains comfortable to use on smaller screens. What You'll Find 🌍 Global Comfort Food DASTAN brings together dishes and stories from different parts of the world. Examples include: Tonkotsu Ramen — Japan Hyderabadi Dum Biryani — India Kimchi Jjigae — Korea Lasagna alla Bolognese — Italy Lahori Chicken Karahi — Pakistan Each one is presented as more