Techlist.io - Korean Tech Blog Curator

datadogAug 23, 20161 min readCurated summary

Restroom hacks | Datadog

Datadog announces that Gartner named it a Leader in the 2026 Magic Quadrant for Observability Platforms. The supplied content primarily consists of Datadog’s navigation menu, so it does not provide the report’s evaluation criteria, supporting evidence, or detailed conclusions. ## Datadog’s Gartner Recognition - Datadog is presented as a Leader in Gartner’s Magic Quadrant for Observability Platforms. - The announcement links to a Datadog resource about the 2026 report. - No specific Gartner strengths, cautions, ranking details, or competitor comparisons are included in the provided text. ## Datadog’s Product Scope The navigation indicates that Datadog offers capabilities across: - Infrastructure and cloud monitoring - Application performance monitoring and profiling - Logs, metrics, databases, and data observability - Security monitoring and vulnerability management - Digital experience monitoring, synthetic testing, and session replay - CI/CD and software delivery observability - Incident response, service management, and workflow automation - AI-agent observability and AI-assisted investigation The material provided is insufficient for a deeper summary of the blog post’s argument or supporting technical details.

Read original

Kubernetes Datadog Observability Application Performance Monitoring+3

figmaAug 22, 20162 min readCurated summary

Introducing Figma’s Integration with Framer | Figma Blog

Figma announced a one-click integration with Framer in August 2016, responding to strong user demand for better prototyping workflows. The integration lets designers import Figma assets directly into Framer instead of exporting layers individually and uploading them manually. Together, the tools connect Figma’s rapid UI design and iteration with Framer’s expressive, code-based prototyping. ## The Need for Better Prototyping - Static mockups are insufficient for designing mobile and interactive experiences. - Designers need to: - Design within the context where a product will be used. - Demonstrate how screens respond to user input. - Add motion, transitions, and other interactive details. - Earlier workflows often required After Effects or manually building HTML, JavaScript, and CSS prototypes. - These approaches were cumbersome, involving remote servers, FTP uploads, mobile testing over 3G, and browser compatibility issues. ## Figma and Framer Integration - Figma users can import assets into Framer with one click. - The integration removes the need to export and upload layers individually. - It creates a faster path from visual UI design to interactive, code-based prototypes. - The feature was especially significant because Framer was the prototyping tool most frequently requested by Figma users. ## Complementary Strengths - Figma supports quick UI design and team iteration. - Framer enables open-ended, code-based prototypes, particularly for complex single-page interactions. - The combined workflow helps designers move ideas into code faster, test them in realistic interactions, and ship better products sooner. - The partnership also reflects Figma’s belief that code-based prototyping can be accessible to a broader generation of designers. The integration was intended to make prototyping more efficient by combining Figma’s collaborative design workflow with Framer’s flexibility and expressive coding environment.

Read original

Figma Prototyping JavaScript CSS+4

datadogAug 11, 20161 min readCurated summary

Consul at Datadog | Datadog

The provided content does not include the blog post itself. It contains a Datadog promotional banner announcing its recognition as a Leader in Gartner’s Magic Quadrant for Observability Platforms, followed by the website’s navigation menu. ## Datadog’s Observability Offering - Infrastructure monitoring, metrics, containers, Kubernetes, networks, serverless systems, and cloud costs - Application performance monitoring, profiling, dynamic instrumentation, and agent observability - Logs, database monitoring, data pipelines, and data quality tools - Security, digital experience monitoring, software delivery, incident management, and AI features ## Promotional Announcement - Datadog promotes its recognition as a Leader in the 2026 Gartner Magic Quadrant for Observability Platforms. - The provided excerpt does not include Gartner’s evaluation, Datadog’s supporting arguments, or the article’s technical discussion. The actual blog text is needed for a meaningful technical summary.

Read original

Kubernetes Datadog Observability Application Performance Monitoring+3

datadogAug 11, 20163 min readCurated summary

Consul at Datadog

Consul has become a critical part of Datadog’s production infrastructure for distributing configuration and discovering services. After 18 months of use, the main lesson is that Consul requires careful capacity planning, controlled access, efficient query patterns, and continuous monitoring. The recommendations aim to keep clusters stable while supporting frequent configuration updates and high-volume service discovery. ## Consul Server Capacity and CPU Consul servers use Raft consensus to elect a leader and coordinate the cluster. - Followers trigger a leadership transition if they cannot hear from the leader for 500 milliseconds. - Frequent leadership transitions usually indicate insufficient CPU capacity. - Datadog’s approximate sizing guidance: - `m3.large`: about 300 agent nodes - `c3.xlarge`: about 500 agent nodes - `c3.2xlarge`: about 800 agent nodes - If transitions occur hourly or more often, increase server CPU capacity until they happen no more than daily. - Standard monitoring may miss brief 500-millisecond CPU spikes, so reducing CPU pressure is important even when dashboards look normal. ## Auditable Configuration Changes Consul’s key-value store is useful for distributing configuration throughout a cluster. - Configuration can be retrieved through HTTP or delivered through Consul watches. - Direct edits without an audit trail make it difficult to determine who changed a value and when. - `git2consul` distributes configuration from a Git repository, providing version control and accountability. - Datadog uses it for cluster-wide configuration updates roughly every 60 seconds, dozens of times per day. ## Access Control with ACLs Consul ACLs prevent unauthorized processes from modifying or deleting key-value data. - Tokens should be limited to the data and operations each process requires. - Scoped permissions reduce the impact of accidental changes. - ACLs provide an important safety boundary between services and configuration areas. ## Watches Instead of Excessive Polling Consul can handle substantial traffic, but it should not be queried hundreds of thousands of times per second like Redis or Memcached. - Watches notify clients when key-value data changes. - This reduces unnecessary polling and distributes updates efficiently. - Watches can sometimes trigger unexpectedly or too frequently. - Tools such as `sifter` can help protect systems from excessive watch activity. ## Using dnsmasq for Service Discovery Applications using Consul’s DNS interface can reduce load by placing `dnsmasq` between clients and Consul. - Use short DNS TTLs; Datadog commonly uses 10 seconds. - Query `dnsmasq` rather than Consul directly so repeated answers can be cached locally. - At very high request volumes, cache Consul services in an additional hosts file loaded by `dnsmasq`. - This setup served over 100,000 DNS requests per second while sending only about 400 requests per second directly to Consul. - `goshe` can collect `dnsmasq` statistics for monitoring. ## Monitoring Cluster Health Monitoring is essential for operating Consul reliably. - `consul.consul.leader.reconcile.count` should remain stable and indicate that a leader exists. - `consul.serf.events.consul_new_leader` shows leadership transitions; frequent events suggest instability. - `consul.raft.leader.lastContact` measures how recently nodes contacted the leader. - `consul.consul.dns.domain_query.count` reveals how many DNS requests are reaching Consul directly. - Also monitor CPU and network usage on Consul servers. Consul works best when server nodes have sufficient CPU, configuration changes are managed through version control, ACLs restrict access, watches replace aggressive polling, and `dnsmasq` absorbs service-discovery traffic. Continuous monitoring of leadership, Raft connectivity, DNS load, CPU, and networking helps identify failures before they affect production.

Read original

Microservices Monitoring Configuration Management Consul+4

datadogJul 11, 20162 min readCurated summary

Releasing czlib and zstd Go bindings | Datadog

Datadog announces that it has been named a Leader in the 2026 Gartner® Magic Quadrant™ for Observability Platforms. The surrounding content presents Datadog as a broad platform spanning infrastructure, applications, data, logs, security, digital experience, software delivery, service management, and AI. The provided excerpt does not include Gartner’s detailed evaluation or the reasoning behind the placement. ## Gartner Recognition - Datadog highlights its designation as a Leader in the Gartner Magic Quadrant for Observability Platforms. - The announcement links to a Gartner-related resource for additional details. ## Broad Observability Platform - **Infrastructure:** Infrastructure and container monitoring, metrics, Kubernetes autoscaling, network monitoring, serverless, cloud costs, storage, GPUs, and Cloudcraft. - **Applications:** Application Performance Monitoring, service monitoring, continuous profiling, dynamic instrumentation, and agent observability. - **Data and logs:** Database and data-stream monitoring, data quality, jobs monitoring, log management, sensitive-data scanning, audit trails, and observability pipelines. - **Security:** Code, cloud, workload, application, API, vulnerability, compliance, SIEM, and secret-scanning capabilities. - **Digital experience:** Browser and mobile RUM, product analytics, session replay, synthetic monitoring, mobile testing, and error tracking. - **Software delivery and service management:** CI visibility, test optimization, code coverage, feature flags, internal developer portals, incident response, SLOs, workflow automation, and case management. - **AI:** GPU monitoring, AI integrations, agent observability, AI-powered investigation and chat, agent builders, MCP support, and related developer tools. ## Platform Capabilities - Datadog also emphasizes shared platform features such as dashboards, notebooks, alerts, Watchdog, access control, governance, fleet automation, and mobile access. - The product organization suggests an integrated approach to monitoring systems, applications, user experiences, security, delivery pipelines, and AI workloads. Datadog’s positioning is that observability increasingly requires a unified platform rather than isolated monitoring tools. Readers seeking the specific strengths, limitations, and evaluation criteria behind the Gartner designation would need to consult the linked Gartner resource.

Read original

Kubernetes Datadog Observability Application Performance Monitoring+3

datadogJul 11, 20162 min readCurated summary

Releasing czlib and zstd Go bindings

Datadog released Go bindings for two C compression libraries, czlib and zstd, to improve compression performance in production data pipelines. czlib addresses the standard library’s slower pure-Go zlib implementation, while zstd offers faster decompression, competitive compression, and modern features such as dictionaries and compression levels. The post concludes that performance depends heavily on payload size and interface, so applications should benchmark representative data. ## czlib: Faster zlib-Compatible Compression - czlib began as a fork of Vitess’s `cgzip` package. - Datadog modified it to use zlib wrapping instead of gzip headers, matching the format used by its primary data pipeline. - It provides: - Non-streaming compression and decompression - Streaming interfaces - Batch-oriented interfaces - The authors recommend benchmarking with realistic messages using: - `PAYLOAD=path_to_message go test -run=NONE -bench .` ## Benchmark Results - For a 2 KB plaintext message: - czlib compression: 44.42 MB/s - Streaming czlib compression: 34.11 MB/s - Standard `compress/zlib`: 9.27 MB/s - czlib decompression: 255.62 MB/s - Standard-library decompression: 66.72 MB/s - For a 1.7 MB message: - czlib and standard zlib had similar compression speeds, around 24 MB/s. - czlib decompression reached roughly 257 MB/s. - Standard-library decompression reached about 121 MB/s. - The results show that czlib’s advantage is especially significant for smaller messages and decompression workloads. ## zstd: A Modern Alternative - zstd, or Zstandard, was developed by Yann Collet, who also created lz4. - At the time of publication, its format had recently been finalized and version 1.0 was pending. - Compared with zlib at compression level 6, zstd: - Compresses slightly faster - Produces a slightly better compression ratio - Decompresses substantially faster - Its features include: - Streaming compression - Configurable compression levels - Precomputed dictionaries - Fixed-length batch compression similar to the lz4 interface ## Go Binding Design - The zstd binding intentionally mirrors the zlib API. - It is designed to be a functional drop-in replacement, aside from a few zstd functions that do not return errors. - Dictionary-building support is available in the upstream repositories. - The binding exposes both advanced streaming functionality and efficient batch compression. Use czlib when compatibility with zlib is required but the standard implementation is too slow; consider zstd for new systems that benefit from faster decompression and dictionary support. Always benchmark with data and interfaces representative of the target workload.

Read original

Database Design Go Benchmarking Compression Libraries+2

figmaJun 30, 20162 min readCurated summary

How to do content design / UX writing in Figma | Figma Blog

Figma enables content designers and UX writers to work alongside visual designers instead of contributing only after interfaces are defined. Its web-based, real-time collaboration makes content decisions visible, supports earlier iteration, and helps teams design what a product looks like and communicates at the same time. The post presents five lessons for using Figma to integrate content into the design process. ## Use Real Content to Inform the UI - Add real or near-real copy as soon as a screen, modal, or interaction is created. - Testing actual content early reveals: - Whether the interface communicates the intended message - Whether there is enough space for the copy - Whether the UI needs to be redesigned - Designing content and UI together prevents late-stage copy changes from breaking established interactions or flows. - This is particularly valuable when content designers join a project after visual design has already begun. ## Start Content-First with Written Conversations - Model interactions as real-world conversations before designing them visually. - Use a dedicated Figma frame or comments to script exchanges between the system and the user. - Role-playing conversations helps teams: - Identify goals and edge cases - Understand flow and information hierarchy - Use natural, human language instead of system terminology - These scripts may not become a final blueprint, but they provide a useful reference throughout iteration. ## Map the Entire User Journey - Content designers need visibility into the complete journey, including what happens before and after a specific screen. - Map the journey collaboratively in Figma, then document the content needs beneath each stage. - This encourages visual design to begin with the user’s content and context. - Shared files make the process more iterative than isolated slide decks, sketch files, or physical whiteboards. - Real-time visibility also helps engineers, product owners, and designers understand the content designer’s contribution across the journey. ## Collaborate and Document with Comments - Figma comments provide a shared space for discussing content and recording the reasoning behind content decisions. - Because the work is visible in the same file as the UI, collaborators can respond to copy choices in context rather than reviewing content separately. - The provided excerpt ends before this section’s detailed examples and remaining lessons. Figma is most effective for UX writing when teams use it from the beginning: write realistic content, model conversations, map journeys, and collaborate directly within the design file.

Read original

Figma User Interface Collaborative Design Ux Writing+2

figmaFeb 8, 20162 min readCurated summary

Introducing Vector Networks | Figma Blog

Figma’s vector networks replace the traditional path model with a more flexible structure that lets users connect, split, and manipulate geometry naturally. The system remains compatible with existing cubic Bézier curves while improving direct editing, strokes, and fills. The result is a vector tool that behaves more like physical drawing and avoids several long-standing limitations of pen-based editors. ## Vector Networks vs. Traditional Paths - Traditional paths are chains of lines and curves connecting two endpoints. - Vector networks allow lines and curves between any points, without requiring one continuous chain. - Users can: - Connect any points together - Delete geometry anywhere - Split and recombine shapes naturally - Attach three or more lines to a single point - Stroke caps and joins work consistently, including at multi-line junctions. ## Direct Curve Manipulation - Existing vector tools typically use cubic Bézier curves with control handles positioned away from the curve. - Figma preserves Bézier compatibility but adds a bend tool for direct manipulation. - Holding Command on macOS allows users to drag the curve itself. - Figma automatically adjusts the underlying control handles to match the desired bend. ## More Intuitive Fills - Traditional vector engines use the winding number rule, where fill behavior depends on curve direction. - This makes fills difficult to understand because users generally cannot see whether curves were drawn clockwise or counterclockwise. - Vector networks automatically fill enclosed regions. - A paint bucket-style tool lets users toggle individual enclosed areas to create holes directly. - Developing this fill system was the most difficult part because earlier approaches required users to manually manage negative space. ## Design Through Iteration - Figma’s team initially explored more advanced curve types but chose to remain compatible with existing vector formats. - User studies showed that many people did not consciously notice vector networks; they simply found the tool behaved as expected. - The contrast became clear when users returned to conventional vector editors and encountered their limitations. - Despite many abandoned approaches and doubts during development, Figma concluded that vector networks offered a meaningful improvement over paths. Figma’s recommendation is implicit: vector editing should prioritize direct manipulation and intuitive geometry rather than forcing users to understand the underlying path mechanics. Vector networks preserve compatibility while making drawing, editing, strokes, and fills substantially more natural.

Read original

Figma Vector Graphics Bezier Curves Vector Networks+2

figmaJan 20, 20162 min readCurated summary

From Furniture to Screens | Figma Blog

Furniture design taught Figma designer Sayer Pease that tools should support people’s activities without becoming the focus themselves. Figma applies this principle through simple, versatile tools, tactile controls, and a restrained visual system that helps designers concentrate on their work. The broader lesson is that useful design principles can come from disciplines far beyond digital product design. ## Tools - A small, well-designed toolset can support both simple and complex work, much like a hammer can build anything from a cabinet to a house. - Figma’s pen tool was designed to feel more like a physical pen. - Its vector objects use networks of connected points rather than traditional paths, enabling more flexible and natural drawing. - The editor is intended to resemble an organized workbench, with essential tools easy to find and use. ## Control - Familiar, tactile interactions help users feel in control of digital tools. - Keyboard shortcuts provide both physical familiarity and greater efficiency. - Figma’s Command-drag selection heuristic distinguishes containers from their contents. - Users can select nested elements—such as icons inside a toolbar—without selecting the toolbar itself, reducing the need to think about layer hierarchy. ## Color as Semantic Guidance - Figma initially used an almost entirely monochromatic, “unskinned” interface so the product would fade behind users’ designs. - As functionality increased, the lack of visual differentiation made UI components harder to distinguish. - The revised approach uses color without making the interface visually dominant. - Colors add semantic meaning: green indicates actions, while blue indicates selection. - This helps users understand what they are doing at a glance rather than focusing on how the interface works. ## Learning Across Disciplines - Product designers should challenge the assumptions and conventions of their immediate field. - Valuable solutions can come from both historical design practices and unrelated disciplines. - Furniture design provides Figma with principles centered on utility, organization, control, and unobtrusive support. Ultimately, digital tools should enable users’ creativity rather than compete with it. Designers can improve products by studying how other disciplines create tools and environments that quietly support meaningful work.

Read original

Figma Design Systems User Experience User Interface+2

figmaDec 14, 20152 min readCurated summary

Slack From the Start | Figma Blog

Figma chose to build its collaboration experience around Slack rather than recreate messaging and notification features. User research showed that Slack was already central to designers’ daily workflows and correlated with more transparent collaboration. By making a Figma team a Slack team and routing notifications through Slack, Figma aimed to reduce tool fragmentation and strengthen its core product. ## Why Slack Mattered to Figma’s Users - Figma interviewed many designers about file storage, specifications, and product decisions. - More than half of the designers surveyed reported using Slack throughout the day. - Slack adoption was associated with more open and transparent design processes. ## Building on Slack Instead of Duplicating It - Figma considered recreating communication features inside its own product. - The team rejected that approach because it would create another inbox and require users to manage teams in two places. - Instead, Figma built its collaboration model on top of Slack: - A Figma team corresponded to a Slack team. - Figma file notifications were delivered through Slack. - Communication about design remained connected to users’ existing workflows. ## A Strategic Platform Bet - Figma viewed Slack as a platform well before Slack formally celebrated its platform launch. - Deep integration was considered a significant product and business bet. - Early results suggested the strategy was working, and Figma expected other companies to adopt similar integrations. The practical lesson is to integrate with tools users already rely on rather than reproducing their functionality. For Figma, treating Slack as foundational reduced friction and made collaboration feel like part of an existing workflow.

Read original

Figma Slack Collaboration Api Integration+2

figmaDec 14, 20153 min readCurated summary

Grid Systems for Screen Design | Figma Blog

Swiss grid design remains relevant to digital products, but traditional fixed-page tools do not handle fluid screen sizes well. The post argues that flexible grids can preserve visual coherence while adapting to different devices. Figma’s solution combines constraints, layout grids, and nested frames to create responsive design systems with precise alignment. ## From Fixed Pages to Fluid Screens - Swiss designers such as Joseph Müller-Brockmann and Karl Gerstner systematized printed-page layouts using rational grid structures. - Traditional grids assumed fixed page dimensions and precise control over typography, margins, and spacing. - Digital interfaces must accommodate changing screen sizes, shapes, and pixel densities. - Designers often compensate with multiple artboards, repetitive adjustments, or guesswork when tools are built around static layouts. ## The Core Building Blocks Figma proposes three complementary features: - **Constraints:** Define how an object responds when its containing frame changes size. - **Layout grids:** Provide detailed alignment and sizing rules across a design. - **Nested frames:** Allow different parts of a design to use their own layout systems. The greatest flexibility comes from combining all three rather than using them independently. ## Constraints for Responsive Behavior - Objects can be anchored to the left, right, or center of a frame. - Objects can also stretch to fill available space. - Constraints provide a basic way to preserve relationships as a frame expands or contracts. ## Stretchable Layout Grids - Grids provide more granular control than simple edge or center constraints. - A box spanning two grid columns can grow or shrink while remaining aligned to those columns. - Column grids can organize text, toolbar icons, and other interface elements—not just web-page content. - Stretching grids allow layouts to respond naturally to changing screen dimensions. ## Frames Within Frames - Nested frames let different sections of a design use separate grids and alignment rules. - This makes it possible, for example, to keep toolbar icons aligned to one grid while allowing the main content to follow another layout. - Frames provide more functionality than static artboards because they support responsive relationships and hierarchical layout systems. - The structure resembles nested HTML `<div>` elements, making it closer to how designs are implemented in code. ## Toward Better Design Tools - Responsive layout systems are only a starting point for improving digital design tools. - The post encourages designers to reassess inherited conventions and look to historical design practices for useful ideas. - Modern tools should combine the coherence of traditional grids with the flexibility required by variable screens. Figma’s recommended approach is to build designs from nested frames, stretchable grids, and well-defined constraints, creating systems that remain organized without being tied to a single screen size.

Read original

Figma Design Systems HTML Responsive Design+3

figmaDec 6, 20153 min readCurated summary

Building a professional design tool on the web | Figma Blog

Figma set out to prove that a professional, high-fidelity design tool could run reliably in the browser. The challenge was that the web exposed specialized features rather than general-purpose graphics primitives, so Figma effectively had to build “a browser inside a browser.” Its solution combined C++ compiled through Emscripten with a custom rendering engine, enabling tighter control over memory, performance, and cross-platform consistency. ## Building Beyond the Web’s Original Design - The web was originally designed for documents, with application features added later as isolated APIs. - This limits advanced applications: - CSS provides sophisticated text layout but does not expose or customize the layout process. - Browsers have optimized GPU compositors, but developers cannot directly modify compositing or add custom blend modes. - Image decoders are highly optimized but offer limited control over details such as EXIF orientation and color-space handling. - Technologies such as WebGL and asm.js began exposing lower-level access to hardware, making demanding browser-based graphics applications practical. ## C++ and Emscripten - Figma’s editor was written in C++ and cross-compiled to JavaScript using Emscripten. - Emscripten targeted asm.js, allowing JavaScript engines to generate predictable and compact machine code. - This approach provided: - Direct control over memory layout, including compact 32-bit floats and bytes instead of JavaScript’s 64-bit numbers. - Manual allocation that avoids garbage-collection pauses and helps maintain 60 fps. - LLVM optimization and C++ template specialization for performance approaching native code. - More predictable execution because asm.js avoids the deoptimization points common in regular JavaScript. ## Memory Constraints and Indirect Buffers - Large contiguous typed-array allocations caused problems, especially in 32-bit Chrome on Windows, where address-space fragmentation from ASLR could prevent allocations as small as 256 MB. - Figma created an `IndirectBuffer` API to reference external typed arrays from C++. - Moving large image and geometry buffers outside the main heap: - Reduced fragmentation during long sessions. - Allowed better use of limited 32-bit address space. - Helped bypass typed-array size limits in 64-bit browsers. - The post also points toward future improvements from WebAssembly, which would reduce asm.js parsing costs, and shared typed arrays, which would enable shared-memory multithreading. ## Custom Rendering - Figma implemented its own rendering engine to achieve fast, consistent output across platforms. - Rather than relying entirely on browser graphics implementations, the team began building the rendering layer needed for a professional design application. Figma’s broader recommendation is to use low-level browser capabilities such as WebGL and compiled code when standard web APIs cannot provide the required performance or control.

Read original

Webassembly C++Webgl Asm Js+3

figmaDec 2, 20152 min readCurated summary

Design Meet the Internet | Figma | Figma Blog

Figma’s 2015 launch post argues that creative software should become online, real-time, and collaborative, just as tools like Google Docs had done for documents. Enabled by WebGL, Figma aims to bring powerful vector design into the browser while solving designers’ fragmented collaboration workflows. The company introduced its preview release after three years of development and announced $18 million in funding. ## Why Design Tools Needed the Internet - Designers increasingly work across teams, sharing assets, refining marketing copy, and preparing specifications for engineers. - Unlike engineers, designers lacked integrated tools for designing, commenting, sharing, and storing work collaboratively. - The authors believed browser limitations had prevented creative applications from moving online. ## WebGL Makes Browser-Based Design Possible - Co-founders Dylan Field and Evan Wallace began exploring WebGL in 2011. - Wallace demonstrated that WebGL could reproduce server-side image processing directly in the browser. - This led them to pursue a browser-based creative tool supported by the Thiel Fellowship. - Building Figma required solving difficult problems involving: - Vector rendering - Font layout - Browser performance - Stability across many edge cases ## Introducing Figma - Figma is a browser-based vector interface design tool designed for team collaboration. - The team spent eighteen months using the product internally and working with alpha customers. - Collaboration features included: - Sharing designs through links - Providing contextual feedback - Establishing shared brand colors - Keeping design work accessible in one place ## Preview Release and Future Plans - Figma launched a preview release that invited teams to try the product and influence its roadmap. - Planned improvements for 2016 included: - A stronger Slack integration - Shared team asset libraries - Simultaneous multiplayer editing - The company had raised $18 million from Greylock, Index, OATV, and prominent angel investors. Figma’s launch positioned the browser as a viable platform for professional creative tools. Its practical recommendation was implicit: teams should adopt collaborative, web-based design workflows rather than rely on disconnected desktop applications.

Read original

Figma Real Time Collaboration Webgl Browser Based Design+2