What I like most about figma is how easy it is to collaborate with others in real time. I've worked with tools where sharing designs felt like a task, but with figma, it's as simple as sending a link. Multiple team members can on the same file without conflicts, which really speeds up the workflow,

The interface is also very clean and intuative. Even if someone is new to design tools, they can get comfortable within a short time, Features like auto-layout, components, and plugins save a lot of time and make design systems easier to manage. Review collected by and hosted on G2.com.

One thing I've noticed is that performance can slow down a bit when working on very large files or complex prototype, especially on lower-end systems. Also, since it's browser-based, a stable internet connection is important offline capabilities are still limited.

That said these issues are not major blocker for me, but there's defineitely room for improvement in performance optimization. Review collected by and hosted on G2.com.

The best part about Figma is how open-ended it is. You go in thinking you’ll use it for one thing, and suddenly it’s your design tool, prototyping tool, and presentation builder. We use it for social content, website concepts, and internal decks. I still find new features randomly, which says a lot. Review collected by and hosted on G2.com.

The biggest downside for me is the learning curve. It’s powerful, but not always the most intuitive when you’re starting out. There’s a bit of a “figure it out as you go” phase before everything clicks. Review collected by and hosted on G2.com.

What I like most about Figma is its real-time collaboration, which makes teamwork seamless and efficient. The intuitive interface and powerful design tools also help speed up the entire design process. Additionally, being cloud-based allows easy access and sharing from anywhere. Review collected by and hosted on G2.com.

One downside of Figma is that it can become slow or laggy when working on large or complex files. Some advanced features are limited compared to other design tools, which can be restrictive for more detailed workflows. Additionally, it relies heavily on an internet connection, which can be inconvenient at times. Review collected by and hosted on G2.com.

Figma is a very amazing tool i regular use at my motion design studio because it really helps me to create amazing moodboards storyboards and it helps me to review my team's material too and then we can send it easily tp the client. Ui is smooth. Review collected by and hosted on G2.com.

For figma you need to have an active internet connection, that is the downside. unlike illustrator you can not work smoothly without internet on figma and also it lags sometimes in handling large files such as large storyboards and moodboards Review collected by and hosted on G2.com.

The UI is intuitive and user-friendly, and it’s very easy to pick up if you’re already familiar with Adobe products. I also like the effect options—things like layer blur help me create stunning designs easily.

There are a wide range of plug ins available, and the platform is superfast with no lag or loading times.

Gradients are handled better too, with hardly any banding compared with more traditional apps like Adobe Illustrator. On top of that, I can easily design web pages and build out component libraries. There’s also a great community around the platform, with lots of inspiring designs. Review collected by and hosted on G2.com.

The custom vector-building tools aren’t as flexible as programs like Adobe Illustrator. Review collected by and hosted on G2.com.

This is the best web and app design program out there. They keep adding features that make creating things easy, and I really appreciate how the platform continues to improve. I especially love the new AI agents they’ve introduced to the platform. Review collected by and hosted on G2.com.

Since it does so much it can be overwhelming to learn everything. Review collected by and hosted on G2.com.

It has a bunch of different tools, like slides, design features, a board, an AI coder, and more. Overall, these make it easier for me to create different things and designs in Figma without much trouble.

It also helps that the software has plugins. They’ve helped me add different things in Figma while designing, like icons or placeholder frames. These plugins also helped when I wanted to shift my Figma design to some different software, like Framer or Webflow, although the transfer doesn’t always go smoothly. Sometimes things change on their own, like the auto layout, shapes, or positioning.

When there’s no internet, I personally didn’t realize I was working offline, which caused delayed syncs with other people working on the same project. For pricing, I’m on a student account, so I’m not having to pay anything as such, but I do feel the pricing is probably high for a designer in India.

Overall, the app didn’t feel too hard to use. There have been a few confusing moments, like when making slides and switching between slides and design/edit mode, but I guess I’ll get used to it later on. Review collected by and hosted on G2.com.

I think the app could benefit from having some integrated plugins in a more accessible spot, so I don’t have to keep going back to the Plugins tab and reopening the one I just closed just to get a clearer view of the app. It doesn’t take a lot of time, but it does distract me a bit. For example, it would be nice if I could pin a plugin—like the Phosphor icon plugin—into a side tab myself for quicker access.

Other than that, I haven’t really run into many issues yet, since I’m still exploring the software. Review collected by and hosted on G2.com.

I use Figma for UI/UX designing for apps, webapps, and websites. Figma addresses my main issues of time and workload with features like auto layout, variables, and components that drastically reduce time consumption and workload. I like Figma's user interface. Figma's plugins and Figjam are very useful; Figjam makes creating flowcharts and wireframes much easier, and the plugins help with product testing or creating UI features not available directly in Figma, like pie charts. The initial setup of Figma was quite easy, and I did not have any problems setting up or learning it. Review collected by and hosted on G2.com.

Heavy files sometimes crash the application. Being offline doesn't let us load a new file or access component library, making offline work heavily restricted and even unusable. Prototype lags a lot on my workstation, making it a bit lighter may help a lot. Review collected by and hosted on G2.com.

I find Figma incredibly easy to use, which allows me to make good-looking content quickly and seamlessly across all media. I appreciate the ease of use and the price, making it a great tool for scaling up internal production quickly. The initial setup was extremely easy. The number of integrations are also helpful, and easy to set up/use. Review collected by and hosted on G2.com.

It's not possible at the moment to make more complex components - we'd like to completely scope out a website to send to our dev team, but it's not quite there yet. Review collected by and hosted on G2.com.

The single file that carries an idea from a rough wireframe to a developer-ready spec is the reason Figma sits at the center of how my team works. We start a feature in low fidelity, sketching boxes and arrows to argue about flow, and we never have to migrate that thinking into a different tool when it firms up. The same frame that held a grey-box wireframe on Monday holds the high-fidelity screen by Thursday and the annotated handoff by the following week. Nothing gets re-drawn in a second application and nothing gets lost in the translation between tools, which used to be where half our rework came from.

Auto layout is the feature I would fight hardest to keep. Once a frame is set to auto layout, it behaves like a real container: padding, gap, and direction are properties I set rather than pixels I nudge, and content reflows when I change anything inside it. Building a card that grows with its text, a button group that spaces itself evenly, or a list that stacks and re-spaces as items are added all happen without manual alignment passes. The closer my layers behave to how flexbox behaves in the browser, the less surprises a developer hits later, and auto layout is what closes that gap. It took my team a little while to stop fighting it and start designing with it from the first frame, but once that clicked, the speed difference on every iteration after was hard to overstate.

Variables changed how we run a design system, and this is the part that matters most for end-to-end work. We define primitive values for color and spacing, layer semantic tokens on top, and use variable modes to flip an entire file between light and dark or between brands. A single change at the token level propagates through every screen that references it, so a brand color adjustment that used to be an afternoon of find-and-replace is now one edit. The variable architecture mirrors the way the front-end team structures their own tokens, which means the design system and the code system finally speak the same language instead of drifting apart release after release.

Components and variants are the backbone underneath all of that. I build a component once, expose its states as variants (default, hover, disabled, the size range), and every instance across the file inherits updates from the main component. When the system changes, I edit the source and watch it ripple through hundreds of placements. Component properties let me wire up text, boolean toggles, and instance swaps so a single button component covers the dozen configurations a real product needs without me maintaining a dozen near-identical copies. For a team trying to keep a large product visually consistent, this is the difference between a maintainable library and a graveyard of detached one-offs.

Prototyping is where the static screens earn their keep before any code is written. I draw connections from interactive elements to destination frames, set the trigger and the transition, and use Smart Animate to interpolate between matching layers for movement that actually reads like the real thing. Running that prototype on a phone through the Figma mobile app gives stakeholders something they can tap and react to, which surfaces flow problems while they are still cheap to fix. Catching that a back button leads nowhere, or that an empty state was never designed, during a prototype review is far better than catching it in a sprint demo.

Real-time collaboration is the thing everyone mentions first, and it deserves the attention. Multiple people in one file, cursors visible, edits landing live, comments pinned to the exact pixel they refer to. The comparison to a shared document for design is fair and it holds up in daily use. A design critique where the whole team is in the file at once, leaving threaded comments on specific frames, replaces a meeting where I would have screen-shared and narrated. Async feedback overnight from a teammate in another time zone is waiting for me in the morning, attached to the thing it concerns rather than buried in a chat thread.

Dev Mode is what makes the handoff honest. A developer opens the file in Dev Mode and reads exact measurements, spacing values, color tokens, and generated code snippets straight off any element, without having to ping me to ask what a margin is supposed to be. Marking a frame as ready for development gives engineering a clear signal about what is settled versus what is still moving. Code Connect goes a step further by mapping a Figma component to its real counterpart in the codebase, so the snippet a developer sees points at the actual component they should use rather than generic markup. On the projects where we set that up properly, the volume of clarifying questions during a build dropped noticeably.

FigJam sits at the front of the same lifecycle and shares the environment. Discovery workshops, user flow mapping, and sprint retros happen on a FigJam board, and because it lives next to the design files, moving from a flow we sketched together into the actual screens is not a tool switch. Dot voting and the lightweight facilitation features make a remote workshop run about as well as a room with sticky notes, and the board stays as a durable record we can return to rather than a photo of a whiteboard nobody can read a month later.

The cross-platform, browser-based nature is a quieter advantage that affects hiring and onboarding more than people expect. Figma runs the same on Windows, Mac, Linux, and a Chromebook, so a new designer is productive on whatever machine they already have, and I have stopped treating hardware as a constraint on who I can bring onto a project. A reviewer or a client who needs to look at something just opens a link in a browser. No install, no license dance, no version mismatch.

The plugin and community ecosystem fills the gaps the core tool leaves. Pulling in icon sets, generating placeholder content, running an accessibility contrast check, automating a repetitive cleanup, most of what I reach for has a community plugin that does it, and the community files are a genuine head start when I want a reference pattern rather than a blank canvas. Review collected by and hosted on G2.com.

Performance on large files is the friction I hit most often, and it is real. A file that has grown to hundreds of frames with deeply nested components and heavy prototypes starts to feel sluggish, especially when several of us are editing at the same time. Pan and zoom lag, selections take a beat to register, and the occasional spinning load on a complex page breaks the flow right when I am moving fast. My team has learned to manage it by splitting big projects across multiple files, archiving exploration pages we no longer need open, and keeping the truly heavy prototypes in their own file, but that is a discipline we have to impose rather than something the tool handles gracefully on its own. For a product that lives in the browser, the weight of a mature file is the cost that shows up as you scale.

Offline access is the limitation I trip over when I travel. Figma is built around the cloud, so a flaky connection on a train or a plane means I am either locked out or working on borrowed time before the file fails to sync. There is some tolerance for a brief drop, but it is not a tool I can rely on for a long stretch with no internet. For anyone whose work is genuinely mobile, this is worth knowing going in. My workaround is to front-load anything connection-dependent before I leave a stable network, which works but is not how I should have to plan my day.

The dependence on third-party plugins for things that feel like they should be native is the next one. The plugin ecosystem is a strength, but it is also a tell: certain workflows that I consider basic still rely on a community plugin, which means extra setup, an extra thing that can break on an update, and an extra trust decision about a plugin that has access to my file. When a plugin I depend on goes unmaintained, I am suddenly hunting for a replacement mid-project. I would rather see a few of the most common plugin use cases absorbed into the core product.

The learning curve is steeper than the marketing suggests, particularly for the features that make Figma powerful rather than just usable. A newcomer can draw rectangles on day one, but auto layout, variables, variable modes, and a properly structured component library take real investment before they pay off, and a team that adopts Figma without putting in that learning tends to end up with a messy file that fights them. I have watched designers coming from other tools struggle with auto layout specifically, because it asks them to think in terms of structure rather than absolute position. My standing advice is to budget time for the team to actually learn the system features, not just the canvas, because that is where the value lives and where the early frustration concentrates.

The AI features are promising but uneven, and I want to be measured about them. The text-to-UI drafting is genuinely useful for getting unstuck or exploring a few directions quickly, but the output is built on generic libraries rather than my own design system, so it is a starting point I have to rework rather than something I can ship. The interaction-adding tool saves time on wiring up prototypes when it guesses the connections correctly, and costs time when it does not. They are a help at the edges of my process rather than a transformation of it, and treating them as more than that leads to disappointment. Review collected by and hosted on G2.com.