Design Collaboration Software

🧭 How To Build A Product UX Glossary For Your Team (https://lnkd.in/edyyFgXB), a wonderful article on how to improve internal communication by establishing a shared vocabulary across all communication channels — to avoid misunderstandings with designers, developers, stakeholders and customers down the line. Neatly put together by Lisa Vorobeva. 👏🏼👏🏽👏🏾 🤔 Poor communication is often the main complaint in teams. 🤔 Every team uses its own obscure language and vocabulary. 🤔 Words like home, nav, filter, dialog, pills can mean many things. ✅ Glossary is a central place for terms and phrases we use. ✅ Useful for customer-facing microcopy and internal chats. ✅ Start with a Google Doc, Figma, Miro or anything else. ✅ First, study words that often cause confusion across teams. ✅ For each, write an explanation and meaning for other teams. ✅ Include screenshots to explain the context where it’s used. 🚫 Add stop words: variants that should no longer be used. ✅ Include “translations” to plain language for other teams. ✅ Make ambiguous terms specific (Home → Dashboard Home). ✅ Invite teams to review internal abbreviations and project names. ✅ Specify if a term belong to a specific flow (Dashboard → Tasks). ✅ Set up reviews every 6 months to keep the glossary updated. As designers, we often speak a different language than our colleagues do. It’s not because we are that different from everybody else; it’s just that every field — from engineers to marketing to business — rely on specialized models and ways of thinking that are unknown to people outside that circle. With these models come words, terms and abbreviations that reflect the perspectives and mental models that we all as product or service people use to map the messy, contradictory, confusing and complex real world to our problem space, and eventually to our solution space. Unsurprisingly, one of the most common challenges in every team I’ve been working with is poor communication. As designers and engineers and marketers and business people, we seem to be speaking the same language — but with sharply different accents, often using ambiguous words with very ambiguous meaning. The best thing we can do to indeed speak the same language is to leave less room for interpretation. Speak explicitly. Avoiding generic terms. Avoiding obscure industry-specific terms when speaking with non-designers. Be a bit more precise about what you mean and show what you mean by saying it. A wonderful reminder by Lisa Vorobeva that something as simple as a shared glossary might be a helpful step towards better shared understanding for the entire team. It might not solve all communication issues right away, yet slowly but surely it can help avoid endless debates and friction due to a simple misunderstanding. How do you solve communication challenges in your company? [useful resources in the comments ↓] #ux #design

The most important feature for Power Automate Desktop since the connectors landing in the asset library (at least) has now finally arrived! The May 2026 update (version 2.68) has come out last week. And while I initially covered what I noticed right away, there was something that took a few more days to roll out (probably due to required updates to underlying services, too). And it is something truly special - version control finally has line-by-line version comparisons! This is so big, I honestly think release to just do this alone would have sufficed. But the team also included several other nice features that I already covered earlier, while also shipping this! What this basically mean is that we can finally compare versions together and see the exact changes that were made. This will significantly improve code review capabilities, as well as accountability in developer teams. It will make it much easier to ensure proper solution quality among professional developers. We can easily see all changes made to all the actions, variables and subflows within a flow. The navigation is clear and intuitive, and it's really easy to see the type of change (added, removed or modified) on each object. If we click on the change, we can also see details (mostly useful for modifications). I also love how actions are grouped under subflows in the overall action changes list. I can also see sections to compare UI elements and images in the view, but it doesn't seem to be comparing those for me yet (even in flows that do have them). Must be something that will roll out a little later. But this is still pretty cool already. Especially since comparing UI elements and image details might be tricky in a sort of a line-by-line comparison. But seeing the fact some (and which) of them had been modified would be nice. The way this works is that we need to select two versions, using each of their context menus and choosing "Compare this version". When we do this on two versions, the comparison view pops up and shows all the changes. This is quite cool, because we don't even need to pre-load a version to compare it with another one. We can actually stay in the currently published version and compare some completely different versions at the same time. It may need a few more improvements and I have already told the product team about those. I personally would like to be allowed to reject or at least comment on a version and request changes. But what we get with this update is already awesome. Great work by the Power Automate team!

One of the most important relationships at any tech company: engineering and design. When this partnership falters, brilliant ideas die on the vine. When it thrives, just about anything is possible. Since I joined in 2015, we've tested many ways to partner across disciplines. The traditional "designers create, then throw specs over the wall to engineers" approach? That’s long gone. Here's what works for us: 1. Erase the handoff mentality entirely Our strongest teams have designers and engineers working in parallel from day one. Engineers join design discussions early, providing technical guidance while concepts are still fluid. This prevents the scenario of a beautiful design proves technically impossible after weeks of work. 2. Create rapid feedback loops Julie Wang is an engineer on our team who has partnered really well with design. A tip she shared recently: "I send screen recordings at all milestones so designers can critique early." The earlier this partnership starts, the more time engineers have to fix bugs, too. 3. Value hybrid skills Our most successful products come from teams where engineers understand visual principles and designers grasp technical constraints. When team members can translate between these worlds, implementation remains true to the vision. 4. Communicate constantly – not just at milestones We've use dedicated Slack channels where work-in-progress is shared continuously. Questions are answered in minutes, not days. 5. V1s, not MVPs We've officially banned the term "MVP" at Duolingo – a policy that received spontaneous applause when I mentioned it at #Config2025 recently. Instead, we focus on shipping "V1s" that genuinely meet our quality standards. Your first version should be something you're proud of, not something you're apologizing for. Big picture: if the relationship between engineering and design is strong and fluid – and everyone has a sense of ownership – there is no ceiling to what you can build. 

The Power of Specific Feedback: How to Guide Your Team to Real Improvement I once skimmed a design document from a team member, AL, and instantly felt it missed the mark. Something was off—maybe the clarity, maybe the depth. “This needs improvement,” I said. AL revised it and brought it back. Still not quite right. “Try making it clearer,” I suggested. Another round of edits, another submission. Still, something felt off. Finally, AL looked at me, exasperated. “Joseph, what exactly should I improve?” That’s when it hit me—my feedback was useless. Vague advice like “make it better” is like telling an artist to “be more creative” without pointing out if they need sharper lines, richer colors, or a different perspective. It wastes time, drains energy, and leads to frustration. So, I sat down with AL and walked through specific gaps—unclear diagrams, weak logic, awkward phrasing. No vague suggestions, just clear, actionable direction. The result? The next draft was client-ready. But more than that, from then on, every report he submitted was sharper, clearer, and more effective. If you want real improvement from your team, don’t just say, “Do better.” Tell them how. Because no one can fix what they can’t see.

I once worked on a design team where everyone secretly wanted to be the best. Not the most helpful. Not the most collaborative. Just… the best. You could feel it in meetings. Every design critique turned into a quiet competition. Who had the “smartest” idea. Who got the most praise from the lead. Who got tagged first on Slack when a new project dropped 😁 . We were all chasing validation instead of alignment. At first, I played along. I would over-polish my screens before sharing them, trying to “wow” everyone instead of working with them. I sha end up designing beautiful nonsense most of the time. It felt good, until I realized something. 👉 Our designs weren’t getting better. 👉 They were just getting shinier. 👉 The collaboration was missing. 👉 The “we” turned into “me.” One afternoon i got a slack message from a developer, “You guys design amazing stuff, but you don’t design together.” Most of the screens feels different, everyone was busy generating their own components when we should be housing them under one library. If you've been here or maybe going to meet this kind of experience in the future, here is how you can handle it. Start by asking more than you are eager to always present. The product managers will always feel it when you are trying to out perform everyone. Share rough sketches early instead of perfect mockups. It will help you understand better what you will be designing. Give credit openly. ask for help without fear. No one ever designs a full product without missing one or two screens. Even when you know how you could design that one screen better than the junior designer that orignially designed it. Guide them into making the iterations themselves and watch them learn. Don't try to always have every design pattern go your own way. ✅ Watch how the negative energy will slowly shift into a positive one. ✅ Meetings will begin to feel lighter. ✅ Ideas will begin to blend together. ✅ Wins becomes ours, not yours. You don’t become a great designer by outshining your team. You become one by amplifying them. The magic only happens when everyone’s is in sync. By the way, here’s one of my favorite prototypes I’ve ever built in Figma. #protoype #workexperience #uxdesign

Hello World! Many organizations have already figured out how to build AI agents. The next challenge is managing the knowledge those agents rely on. One of the most complex problems in the AI era is no longer selecting the right model. The real challenge is organizing, versioning, governing, and controlling the knowledge that powers AI applications, ensuring traceability, consistency, and reusability across different agents and systems. Over the past few months, I've been exploring this problem while following the evolution of initiatives such as Google's recently introduced Open Knowledge Format (OKF), along with other technologies and emerging standards for AI knowledge management. This exploration led me to build and open source a new project: Agent Knowledge Compiler & Control Plane. The goal is not to introduce another standard. Instead, the project brings together existing concepts, best practices, and emerging standards into a single architecture for organizing, compiling, and governing the knowledge consumed by AI applications. Some of the capabilities the project aims to provide include: • Knowledge organization and compilation • Artifact lifecycle management • Versioning, traceability, and change control • Abstractions for AI applications consuming knowledge • Practical use cases demonstrating the architecture The project is still in its early stages, and many design decisions will certainly evolve over time. That's exactly why I'm sharing it now. I believe infrastructure and platform projects become significantly better when they're developed openly with the community. If you're working with AI applications, agents, RAG, data engineering, or knowledge management, I'd love to hear your feedback: What could be improved? Which capabilities or use cases are missing? Interested in contributing code or documentation? Even reviewing the architecture, opening an issue, or simply giving the repository a ⭐ would be greatly appreciated. 🔗 Repository: https://lnkd.in/dPjwu3Uj My hope is that this project can serve as a starting point for a broader discussion on how we build the knowledge foundations that will support the next generation of AI applications.

Disney just spent $1 billion on AI. Not to replace animators. To solve a problem most studios ignore: variations cost almost as much as originals. Creating 10 variations of a marketing asset used to require full production cycles. Review meetings, approval chains, render time, team coordination. Now: prompt-driven generation from existing asset libraries. Cost per variation dropped from thousands to dollars. Here's how to do this in your business: 1. Audit where you're manually creating variations Pull reports on content production for the last quarter. Filter for derivative work: social posts, email variations, ad formats, localized content. Calculate hours spent on variations vs original content. Most teams waste 40-60% of production time on derivatives. 2. Build pre-approved asset libraries Create folders of brand-approved visuals, copy templates, and style guidelines. Get legal and compliance sign-off once on the entire library. Tag assets by use case, audience, and channel. This eliminates per-output review cycles. 3. Use APIs, not standalone AI tools Connect AI directly into your CMS, DAM, or social scheduling platform. Avoid tools that require exporting and reformatting outputs. Integration should remove steps, not add them. Test: if AI adds more than one click to your workflow, it's wrong. 4. Constrain before you scale Limit which assets AI can access in phase one. Start with lowest-risk content: social variations, email subject lines, ad copy. Expand permissions only after you've proven the review process works. Constraints reduce verification overhead by 80%. 5. Shift from per-output to per-library review Stop reviewing every AI-generated asset individually. Review and approve the source library once. Monitor outputs with spot-checks, not line-by-line edits. Your team should validate systems, not outputs. 6. Measure marginal cost reduction Track cost per variation before and after AI implementation. Include team hours, tool costs, and review cycles. Target: 70-90% reduction in marginal production costs. If you're not seeing this, your integration is wrong. Why this works: Creative teams aren't threatened, they're empowered to experiment more. The bottleneck was never ideas. It was the cost of executing variations. Solve execution cost by removing production barriers, not people. Found this helpful? Follow Arturo Ferreira.

Here is one thing your AI production pipeline is missing: Control. Most teams still presume that AI production is about bouncing between tools and a ton of folders 🤔 But that workflow takes you from creative to operational dragging To achieve enterprise-grade output, you need high control inside the same environment where generations happen. And FLORA's recent upgrade by integrating inpainting, outpainting, and cropping within the tool is the real unlock. Your production team can treat this as a real system rather than some new buttons to push ⚡ This is your guide to leveraging this upgrade for pro-grade AI production: 1. Turn inpainting into your precision repair layer: Use inpainting directly inside FLORA to: → Clean artifacts around faces, hands, and products without touching the rest of the frame → Correct brand details such as logos, textures, or jewelry that must be perfect at 4K → Iterate on one area while keeping seed, lighting, and composition consistent This ensures that there is no version chaos between “final.psd_v6” and “final_final.psd”. Your AI operator stays within a single graph with full context of the shot. 2. Use outpainting to design framing options in one pass: You need to strategically expand your canvas by: → Generating the core hero frame → Using outpainting to add headroom, negative space, or extra environment left and right → Pre-building variations for vertical, square, and cinematic crops inside FLORA This way, you give your creative director multiple layout options from one base image without re-running the entire pipeline. This is where you win back days on campaign timelines. 🎯 3. Make cropping the last gate of quality: Cropping is the framing authority of the pipeline, which is why you need to: → Lock in the exact ratios required by media, e-commerce, or social placements → Standardize where product, character, and branding sit in the frame → Build reusable presets so operators cannot drift from brand guidelines This way, your delivery packs feel more intentional, and every asset is framed, consistent, and ready to drop into edit without redesigns. Now this may feel like a minor feature release over the surface. However, it is a direct upgrade to production pipeline precision, since you gain avid control over how your output is shipped 🦾

CI/CD and #BusinessIntelligence are not terms you usually see in the same sentence. Many BI teams still update dashboards manually, without version control, review processes, or reliable deployment workflows. When your dashboards are mission-critical, that approach creates real risk. This new tutorial shows how analytics teams can ship AI/BI dashboard changes safely at scale using Databricks Asset Bundles and Git-based workflows. You’ll learn how to: • Track every dashboard change with version control • Review and approve updates before they reach production • Deploy dashboards across environments with confidence • Roll back changes instantly if something goes wrong The key idea is simple: production dashboards should be managed like production code. Because AI/BI runs on the Databricks Data Intelligence Platform, teams can apply the same DevOps practices used for pipelines and applications directly to their dashboards. Great work from Eason Gao, Noah Sommerfeld, and Jen L. on a very practical walkthrough. Read the full tutorial below.

Version Control in Power BI: A Professional Approach As Power BI adoption grows across enterprises, one recurring challenge remains: maintaining proper version control. Unlike traditional software development environments, Power BI files (.pbix) are binary. This makes it difficult to: Track incremental changes Compare modifications across versions Manage collaborative development Roll back safely when issues arise Many teams fall into the common trap of maintaining multiple files such as Report_Final_v3, Final_v5_Updated, or Latest_Use_This.pbix. This approach introduces risk, confusion, and governance gaps. The Core Problem Power BI development often involves multiple layers: Power Query (M transformations) Data modeling DAX measures Report design When multiple developers work on the same report, changes can easily overwrite one another. Since .pbix files cannot be diffed natively in Git, tracking modifications becomes manual and error-prone. In enterprise environments, this creates operational risk. A Structured, Professional Solution Organizations that treat Power BI as a strategic platform apply software engineering principles to BI development. 1. Separate Dataset and Report Layer Publish centralized datasets to the Power BI Service and build thin reports connected to them. Using Microsoft Power BI, this architecture minimizes conflicts and ensures consistent data models across reports. 2. Externalize and Version DAX & M Code Instead of versioning only .pbix files: Extract DAX measures Extract Power Query (M) scripts Store them in a Git repository Tools such as Tabular Editor enable exporting model metadata into structured files that can be tracked in source control. This enables: Change tracking Code reviews Rollback capability Parallel development 3. Implement Deployment Pipelines Leverage Dev → Test → Production pipelines within Power BI Service to control releases and ensure validation before production deployment. This enforces governance and reduces production risk. 4. Establish Governance Standards Define naming conventions Maintain structured folder repositories Document change logs Align with enterprise release management processes Version control is not just technical discipline — it is governance discipline. Practical Example In a recent enterprise finance project with multiple developers: Before implementing structured version control: Frequent file overwrites Conflicting DAX logic Limited traceability After implementing dataset separation, Git-based code management, and deployment pipelines: Clear ownership of changes Improved collaboration Faster release cycles Full audit trail The impact was measurable — both in productivity and in risk reduction. #PowerBI #BusinessIntelligence #DataGovernance #AnalyticsEngineering #MicrosoftBI #DataStrategy #EnterpriseBI