Designing for the Internet of Things

💡Hot Potato Process as Replacement for Design Handoff Design handoff is by far the most stressful part of the design process. In many organizations, design handoff causes a lot of friction and back and forth. All too often, it happens because design team thinks about design handoff as a one-directional exchange ("We send them to design, all they need to do is build it"). But in reality, there can be a lot of factors that impact design, from tech feasibility to business requirements. But there is a solution to this problem—The Hot Potato Process, originally defined by Dan Mall and Brad Frost. ✅ What is the Hot Potato Process The process gets its name from the children's game "hot potato," where an object is passed around quickly, with no one holding onto it for too long. Product teams that follow the Hot Potato process pass ideas quickly back and forth from designer to developer and back to designer, then back to developer for the entirety of a product creation cycle. ✅ Why to use the Hot Potato   The best handoff is no handoff. Teams that follow the Hot Potato process don't have a handoff, a separate step in the design process. Instead, they exchange ideas all the time. And this exchange is bidirectional, meaning that designers and developers refine product ideas together in real-time. The prototype designers and devs are working on becomes the living spec of the project. And since the interaction happens on a regular basis, both designers and developers start to use the same language when discussing it. ✅ How to make the most of Hot Potato ✔ Designers and developers sit together Create designer + developer pairs to maximize work efficiency. Ideally, they should sit together in person, but if it is impossible, it's okay to use real-time synchronous tools to simulate working together in a co-located way. For example, have a Zoom chat open during working sessions. ✔ Both designers and developers work together at the same time Unlike the waterfall process, where developers wait for designers to provide a ready-to-implementation design, the Hot Potato process invites developers not to wait for designers. Consider what designers could do while developers are busy and what developers could do while designers busy. This will enable both teams to work together simultaneously. ✔ Iterative prototyping New ideas should be quickly turned into prototypes. Once prototypes are created, they're passed around quickly for feedback and refinement. Each new iteration builds on the previous one, leading to better solutions over time. ✔ Start small  Hot Potato can introduce a radical change in how people design products, so you can expect a lot of pushback from team members. To minimize the risk of resistance to change, start introducing Hot Potato for small projects. Pick one or two projects where you could test the new collaborative approach. Demonstrate the success of the projects to motivate team members to embrace the new approach. #design #ux #ui

The design handoff nobody talks about Design handoff is usually treated as the finish line. But it’s actually where half the value is lost. Developers need context, not just Figma files. They need to know why choices were made, not just what they are. The best design handoffs happen in conversations, not attachments. Every time design and engineering talk early, the product gets better. If you’re managing a team, stop treating handoff as a baton pass. It should be a relay, overlapping, fast, and full of communication.

Manual Handoff is Broken – Here’s the Fix 🚀 Imagine this: You’ve spent weeks perfecting your design. You hand it off to developers, and each one has to manually inspect every element—buttons, colors, borders—across web, iOS, and Android. ❌ Result? Inconsistencies. ❌ Wasted time. ❌ A never-ending back-and-forth between designers and developers. 🎨 Enter Design Tokens. 💡 Instead of developers manually extracting values, what if the design automatically converted into code for any platform—CSS, Swift, Kotlin—without the hassle? In my latest video, I break down: ✅ The complete Design Tokens process—step by step ✅ Why having One Source of Truth is a game-changer ✅ How to move from manual handoff to automated workflows ✅ The tools you need: Figma Variables, Tokens Studio, Style Dictionary ✅ A real-world example of how this process keeps everything consistent across platforms If you’re a designer or developer, mastering this will save you hours of work and make your product more scalable and efficient! 🎥 Watch now: 🔹 Arabic version: https://lnkd.in/gwAAZkhQ 🔹 English version: https://lnkd.in/gUx6k7mK How does your team handle design consistency today? Let’s discuss in the comments! 👇 #design #designtokens #UIUX #productdesign #userexperience #Figma #Figmavariables #designsystem #developerhandoff #automation #consistency #onesourceoftruth #TokensStudio #StyleDictionary #frontenddevelopment #UXdesign #webdevelopment #mobileappdesign #designworkflow #scalability #efficiency

Designers and developers speak different languages. But when they listen early, magic happens. A few months ago, we kicked off a new product build. The usual setup: designers finalize flows, hand off to dev, then... endless Slack threads, clarifying questions, and "this isn't what I expected" moments. Sound familiar? This time, we took a different approach. Instead of working in silos, we brought everyone into the same (virtual) room—from day one. We ran cross-functional workshops: 👉 Designers walked through their thinking 👉 Developers flagged edge cases early 👉 Everyone had a say in feasibility before pixels were polished We used Figma’s handoff tools—not just as a delivery method, but as a shared language. And we held quick weekly syncs to stay aligned, not just at kickoff. The result? ✅ Build time dropped by 25% ✅ Fewer bugs ✅ Zero surprise revisions ✅ And... team morale? Way up. Here’s what I learned: When design and dev teams collaborate early, they don’t just move faster—they trust each other more. And that trust? That’s where the real magic starts. 👥 Tag a designer or developer you love working with. And share your best tip for making the collaboration smoother.

Don't overcomplicate design-to-dev handoffs. Listen up designers, dropping Figma files into the void and praying for the best: Your developers are SILENTLY SCREAMING. And no, it's not because they hate designers. Here's the truth about your current process: • You're designing in isolation • You're skipping documentation • You're ignoring technical constraints • You're using inconsistent naming conventions Instead, here's what actually works: 1. Component Audit First - Map existing components before new designs - Document reusable patterns - Align with dev team's component library 2. Design System Integration - Use real data, not Lorem Ipsum - Define clear states (loading, error, success) - Document responsive breakpoints 3. Collaborative Reviews - Weekly design-dev syncs - Live prototype reviews - Technical feasibility checks early 4. Handoff Documentation - Clear component specs - Interaction flows - Edge cases defined - Accessibility requirements Stop treating handoff like throwing designs over a wall. Start treating it like a bridge you're building together. --- PS: The best designs aren't just beautiful. They're buildable. When's the last time you asked your dev team what would make their life easier? Follow me, John Balboa. I swear I'm friendly and I won't detach your components.

👋 →🤝! Design systems are moving from “hand-offs” to “handshakes.” The big shift: instead of design pushing specs to dev and hoping for the best, new tools like Figma’s MCP, Slots, and AI integration let design and code talk to each other in real time. The system doesn’t just tell teams what to build—it learns from how the product is actually built and used. Why this is great (in plain words): 🍀 Designers and developers work closely as one DS team. Ideas flow both ways. 🍀 Less rigid control, more smart conversations. We learn from the system instead of trying to micromanage it. 🍀 Faster delivery, better quality, and fewer “spec vs. reality” surprises. Yes, there’s a catch: if your tokens, component contracts, and governance are messy, bidirectional sync will amplify the mess. Tighten the structure first—then flip the switch. 🧨 Exciting times! This is how design systems become living engines, not dusty libraries. https://lnkd.in/ehRTYT5d

A developer once told me: "You're my favorite designer to work with." Here's why that matters: Most design teams and development teams don't get along. → Designers want beautiful, complex interactions. → Developers want simple, maintainable code. The result? → Friction. → Delays. And features that take months to ship. I'm different. I'm a designer with an engineering background. I started as a software engineer before I became a designer. And that changed how I approach design. Here's why developers actually like working with me: **1. I understand what it takes to implement my ideas** Most designers have great ideas. But they don't factor in technical complexity. They design something that looks amazing in Figma. Then hand it off to developers who need 6 weeks to build it. I feel their pain. So I don't create them in the first place. I design things that can ship fast without sacrificing quality. **2. I care more about shipping than looking cool** Most designers are focused on whatever looks coolest. → The award-winning interaction. → The smooth animation. → Cool transitions. I care about what gets the feature in users' hands faster. Shipping great features fast gives me more energy than fancy designs. Because I know what actually moves the business forward. It's not the perfect gradient. It's the feature users can use today. **3. I speak developer language** When I hand off a design, developers know exactly what to build. I understand constraints and tradeoffs. I can say: "This needs to be pixel perfect. This can be approximate." I can prioritize: "Ship this part first. We'll iterate on this part later." I don't just throw designs over the wall and disappear. I work with the dev team to make sure it's actually buildable. Here's the result: → Features ship faster. → The product still looks great. → Developers don't dread my designs. Listen, you don't need perfect design. You need design that ships. The best design in the world means nothing if it sits in Figma for 3 months. Want to be a great designer? Learn to code. Not because you need to write production code. But because you need to understand what you're asking developers to build. And that empathy makes you 10x more valuable. What's your take?

Earlier in my career, I worked with a senior software engineer who produced excellent work but there was one recurring issue. His final output often had noticeable UI differences from the provided designs. When I brought this up, his response was that his changes were better because they reused existing components and libraries we already had and made the app more standardized. While there was some truth to that, the lack of communication on his part left QA and PMs scratching their heads when trying to reconcile the application with the original designs. Modern tools like Figma and v0 have made this less of an issue as it’s often harder to create something different from what the actual design is. But the core lesson here is still relevant: communication is critical in software development. If this software engineer told the designer why he was making changes, then there is much less confusion in the whole process when it comes time to QA and review the product. The designer could even start using the same libraries as the app to smooth the process if the engineer prompts them. For software engineers, biasing toward clear, proactive communication can be a game-changer. Is it always fair that you have to ask for clarification to get your job done? Not necessarily and if that’s happening all the time it points to larger systemic issues. But the engineers who communicate effectively, who clarify, collaborate, and ensure alignment, those engineers consistently stand out as the most impactful. What do you think?

🔍 The Critical Lesson: Developer Questions Matter! In one of my early projects, I presented what I thought was a flawless design. The developers, however, bombarded me with questions that I felt were unnecessary at the time. I quickly realized how wrong I was. Developer questions are VERY important and should never be taken lightly. It was an eye-opening moment. Developers have a different perspective, focusing on feasibility, functionality, and implementation. Their questions are not just queries but essential insights that can make or break a project. Here’s how I embraced this lesson: 👍Collaborative Approach: I started involving developers early in the design process. Their input helped foresee potential issues and align the design with technical realities. 👍Valuing Feasibility: I began to appreciate the importance of feasibility in design. A brilliant design that can’t be implemented is useless. 👍Iterative Feedback: I encouraged continuous feedback loops between designers and developers. This ensured that the design evolved in harmony with development constraints. What happened next? ➡️➡️➡️ We delivered a product that was not only visually appealing but also robust and functional. The development process was smoother, and the final product was better for it! This experience taught me to value and respect the developer’s perspective. Their questions are crucial for bridging the gap between design and execution. --- ❓How do you handle developer feedback in your projects? ❓Have you had a similar experience where developer insights significantly improved the outcome? #UXDesign #Collaboration #ProductDesign #DeveloperInsights #UX #software

Your designers and developers are working on the same product, but living in different universes. This critical disconnect is silently sabotaging your timelines, and most leaders never see it until it's too late. After having fixed multiple "failing" dev teams, and here's what I've found: 🚨 It's rarely bad developers causing missed deadlines. A more common culprit? 𝐍𝐨 𝐮𝐧𝐢𝐟𝐢𝐞𝐝 𝐯𝐢𝐬𝐢𝐨𝐧 𝐛𝐞𝐭𝐰𝐞𝐞𝐧 𝐝𝐞𝐬𝐢𝐠𝐧 𝐚𝐧𝐝 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭. When I audit troubled projects, I consistently see: ❌ Designers creating beautiful mockups without understanding technical constraints ❌ Developers building functional code that doesn't match the design vision ❌ No clear handoff process between teams ❌ Each side blaming the other when things go wrong This disconnect costs companies millions in: 💸Rework 💸Missed deadlines 💸Lost market opportunities 💸Team burnout But there's a solution I've implemented repeatedly, with consistent success: 1️⃣ Involve developers in the design process from day one 2️⃣ Have designers attend sprint planning to explain the "why" behind their decisions 3️⃣ Create clear documentation with shared ownership 4️⃣ Implement proper UX → Dev handoff processes with tools like Figma or Zeplin 5️⃣ Schedule weekly cross-team alignment sessions In the not-too-distant past, I helped a SaaS company cut their dev cycle time by half, just by bridging this gap. Their CTO told me: "We thought we needed better developers. Turns out we needed better communication."