Techlist.io - Korean Tech Blog Curator

datadog3 min readCurated summary

Engineering spotlight: Marie-Laure Bardonnet

Marie-Laure Bardonnet’s Datadog career illustrates how engineers can grow through both technical and management paths. After working on Dashboards and Notebooks, she moved into distributed backend systems, eventually leading Datadog’s Logs engineering organization. Her approach emphasizes engineering-informed leadership, deliberate career planning, mentorship, and embracing unfamiliar challenges. ## From Web Engineering to Logs Leadership - Bardonnet joined Datadog full-time in 2017 after interning there. - She began on the Paris-based Dashboards team, where she helped: - Launch the Notebooks product. - Build the backend for a responsive Dashboard layout. - Encouraged by her manager, she transitioned into backend engineering and joined the Logs team. - Logs engineering involved real-time ingestion, processing, enrichment, storage, and querying of millions of log payloads daily. - As Datadog’s products developed shared technical requirements, Logs engineers collaborated closely with a centralized Platform team. - After one year as an individual contributor, Bardonnet became a team lead and later advanced to Engineering Manager II, overseeing both backend and frontend Logs teams. ## Balancing Product Delivery and Technical Health - Her role combines strategic planning, technical decision-making, people development, and recruiting. - At the start of each quarter, teams create OKRs that guide product and technical roadmaps. - Managers balance product priorities with: - Reliability and scalability. - Technical debt reduction. - Cross-team dependencies. - Bardonnet reviews RFCs, incident postmortems, and product documentation to help teams make sound decisions. - She supports both individual contributors and managers by identifying projects that build expertise and leadership skills. - She also participates in weekly hiring committees to recommend candidates and maintain consistent leveling. ## Structuring Teams for Future Growth - As organizations expand, Bardonnet focuses on restructuring teams to improve execution and create better growth opportunities. - Two questions guide this process: - What problems will the organization need to solve about a year from now? - How can everyone progress toward their next career step? - Logs leadership works with Product Management on a three-horizons plan to align future investments with customer needs. - Team design also considers whether each person has appropriately scoped work, meaningful challenges, and sufficient mentorship. ## Building a Self-Directed Career Path - Career planning begins by separating current responsibilities from the work someone ultimately wants to do. - Engineers should reflect on: - What work brings them satisfaction. - What they do well. - What they want to learn. - What legacy they want to leave. - Career goals should be reviewed continuously, organized across different planning horizons, and discussed with leaders. - A strong career path balances personal interests, strengths, learning opportunities, team needs, organizational priorities, and feedback. - Career direction is self-driven and may change over time, but managers and organizational leaders can help identify opportunities and create a suitable path. ## Growth Through Uncertainty - Datadog’s expanding platform and variety of engineering teams mean that career paths differ widely between employees. - Progression may be nonlinear and can require taking risks or accepting unfamiliar challenges. - Growth comes from leaving one’s comfort zone and learning through difficult problems. - Peer feedback helps employees assess whether they are progressing and feel supported. - Regardless of role or trajectory, employees contribute to Datadog’s culture by modeling high standards for quality and delivery. Bardonnet’s experience suggests that career growth is most effective when employees take ownership of their direction while seeking feedback, mentorship, and challenging opportunities from their organization.

Read original(opens in new tab)
figma3 min readCurated summary

AI + Design: Figma Users Tell Us What’s Coming Next | Figma Blog

Generative AI’s impact will depend not only on technical capability but also on how effectively it is designed into products and everyday workflows. A Figma survey of more than 1,800 designers, developers, and executives shows high expectations for AI, but limited evidence that current implementations are delivering meaningful value. The findings point to a risk of “AI feature fatigue” and suggest that thoughtful, user-centered design will determine whether AI becomes genuinely useful. ## Survey Scope and Methodology - Figma surveyed more than 1,800 users between February 26 and March 3, 2024. - Participants included designers, developers, and executives across the US, Canada, Australia, the UK, Japan, France, and Germany. - The research examines how organizations view AI’s near-term impact and how teams are incorporating it into products. ## High Expectations, Limited Results - 89% of respondents expect AI to affect their company’s products or services within 12 months. - 37% anticipate a “significant or transformative” impact. - Executives are especially likely to view AI as important to company goals. - Despite this optimism, 72% of people whose products include AI say it has only a minor or non-essential role. - Only about one-third report improvements in business metrics such as revenue, costs, or market share. - Fewer than one-third say they are proud of what they have shipped. ## The Risk of AI Feature Fatigue - Figma researchers observed growing indifference toward adding “yet another AI feature.” - More than 20% of teams building AI products identify failure to solve a real user need as a major challenge. - This concern is particularly strong among designers. - Fewer than half of respondents working on AI products or features have shipped anything, indicating that a larger wave of AI products may still be coming. - Organizations risk flooding the market with novelty features that users do not find useful. ## Designing AI Into Existing Products - One-third of respondents rank integrating AI coherently into existing products as a top challenge. - Simply adding AI without improving the overall user experience is unlikely to drive adoption. - Teams need to help users understand: - What AI tools are available - When those tools are useful - How AI improves existing workflows - The article uses ChatGPT as an example: its rapid adoption was driven partly by a simple, accessible conversational interface, even though the underlying model capabilities already existed. - Good design can make powerful technology more approachable, aligned with user expectations, and easier to use. ## Practical Implication AI products are more likely to succeed when they address concrete user problems rather than adding AI for its own sake. Organizations should prioritize coherent product integration, clear user experiences, and measurable improvements over ambitious but disconnected features.

Read original(opens in new tab)
figma2 min readCurated summary

23 Prototyping Resources to Bookmark Right Now | Figma Blog

Prototyping is valuable throughout product development—not just at the end—as a way to align teams, gather feedback, conduct research, and improve products through iteration. Figma’s curated collection of 23 resources supports different learning styles, from introductory videos and community files to presentation techniques and advanced prototyping features. ## Cover the Basics - An eight-minute video introduces interactive prototypes, animation, and incorporating tester feedback. - A 50-minute playlist covers: - Easing curves and transitions - Smart Animate - Scrolling - Device frames - A 63-minute “Prototyping 101” video explains basic frame-to-frame navigation and advanced features such as interactive components. - A two-part series for product professionals demonstrates how non-designers can create lightweight prototypes. - Part one covers basic prototype creation. - Part two explores transitions, Smart Animate, scrolling, and other motion techniques. - The “Accessible prototypes in Figma” community file demonstrates prototype accessibility features, including compatibility with screen readers such as VoiceOver on Mac and JAWS on Windows. ## Level Up Presentations - Prototyping can make presentations more dynamic and engaging, whether for boardrooms, classrooms, or other audiences. - A 70-minute video explains how to build interactive slide presentations in Figma. - A short tutorial shows how to embed interactive elements, such as scrollable mobile screens, inside presentation slides. - Another video demonstrates using the Figma mobile app to click through presentation slides. ## A Broader Prototyping Practice - Figma positions prototyping as a tool for: - Building shared team understanding - Testing ideas with users - Facilitating stakeholder feedback - Iterating before development - The resource list follows recent Figma prototyping enhancements, including updates that help bring designs to life across mobile, tablet, and smartwatch interfaces. - The article is organized as a learning path, with additional sections intended to cover video, motion and flow, variables, and recorded office hours. Use the resources progressively: begin with the introductory tutorials, then explore accessibility, presentation workflows, motion, variables, and community examples as your prototyping needs become more advanced.

Read original(opens in new tab)
figma3 min readCurated summary

How Figma's Databases Team Lived to Tell the Scale | Figma Blog

Figma’s database stack grew nearly 100× from 2020, pushing its single-Postgres architecture beyond the limits of vertical partitioning. After adding caching, read replicas, and vertically partitioned databases, the team found that individual tables were reaching terabyte and billion-row scales, creating vacuum reliability issues and approaching AWS RDS IOPS limits. The solution was to pursue horizontal sharding while preserving Postgres, minimizing application changes, avoiding massive backfills, and maintaining consistency and rollback options. ## Scaling from One Postgres Database - In 2020, Figma ran on one large Postgres instance. - By the end of 2022, it had introduced: - Caching - Read replicas - Around a dozen vertically partitioned databases - Related tables, such as those for Figma files and organizations, were grouped into separate database partitions. - Vertical partitioning reduced pressure on the system and provided valuable short-term runway. ## Why Vertical Partitioning Was No Longer Enough - The team monitored multiple scaling constraints, including: - CPU and I/O utilization - Table size - Rows written - Database IOPS - Some tables grew to several terabytes and billions of rows. - Large tables began affecting reliability during PostgreSQL vacuum operations, which prevent transaction ID exhaustion. - High-write tables were on track to exceed the maximum IOPS supported by Amazon RDS. - Because a table is the smallest unit of vertical partitioning, splitting databases by table group could not solve these limits. ## Requirements for the Next Scaling Strategy Figma established several design goals for horizontal scaling: - Minimize developer changes and preserve the existing relational data model. - Make future scale-outs transparent to application teams after initial compatibility work. - Avoid months-long backfills of large tables. - Roll out changes incrementally to reduce outage risk. - Preserve rollback capability after physical sharding. - Maintain strong consistency without relying on difficult double-write schemes. - Support near-zero-downtime scale-outs. - Favor technologies and techniques the database team already understood, given the limited runway. ## Evaluating Alternatives - The team considered CockroachDB, TiDB, Spanner, and Vitess. - Moving to another database would have required a risky migration between storage systems while preserving consistency and reliability. - Figma already had substantial operational expertise running Postgres on RDS; replacing it would mean rebuilding that expertise under severe time pressure. - NoSQL systems were also unsuitable because Figma’s application depends on a complex relational data model and requires the flexibility of relational queries. - The team therefore favored a lower-risk approach that retained Postgres and offered greater control over the migration. ## Practical Direction Figma’s experience shows that vertical partitioning can be an effective intermediate step, but it cannot solve limits imposed by individual tables. For systems with rapidly growing relational workloads, horizontal sharding within a familiar database ecosystem can provide a safer path to scale when it is introduced incrementally and designed around consistency, rollback, and minimal application disruption.

Read original(opens in new tab)
figma3 min readCurated summary

How We Built a Custom Permissions DSL at Figma | Figma Blog

Figma’s original permissions system—a large Ruby `has_access?` method in its monolith—became too complex, risky, and expensive to maintain. As collaboration features expanded, permission rules involving roles, links, hierarchies, organizations, billing, and deleted files caused bugs, delayed projects, and heavy database load. Figma responded by building a custom permissions DSL and cross-platform logic engine to make rules more modular, flexible, performant, and easier to debug. ## Why Permissions Became Difficult - Figma’s collaboration model requires detailed access rules for files and other resources. - Access can come through: - Roles inherited from parent folders, teams, or organizations - Link-sharing settings - User roles and authorship levels - Passwords, expiration periods, and organization restrictions - Originally, permissions lived in a Ruby monolith using ActiveRecord. - A model-level `has_access?` method accepted a user and resource, performed database queries, and returned a Boolean. - Product engineers had to call this method correctly from controllers. ## Problems with the Original System ### Complex Logic and Difficult Debugging - `has_access?` methods grew into long functions with many optional parameters. - Engineers were reluctant to modify them because mistakes could expose access to large numbers of files. - All permission logic for a resource was intertwined, making it difficult to isolate or test individual rules. - Debugging often required adding many print statements and understanding the entire permissions implementation. ### Inflexible Hierarchical Permissions - Permissions were nominally represented by hierarchical integer levels, such as edit access being higher than view access. - Boolean flags introduced exceptions that undermined the hierarchy, including options such as: - `ignore_link_access` - `org_candidate` - `ignore_archived_branch` - A user could have a higher access level but fail a lower-level check when a flag changed the behavior. - These flags differed between resources, forcing engineers to remember numerous special cases. - Figma needed granular, non-hierarchical permissions that could operate independently or define new permission hierarchies. ### Excessive Database Load - As Figma scaled, permission checks accounted for roughly 20% of database load. - This created a serious scalability concern because database capacity had physical limits. - Although the database team was pursuing vertical and horizontal sharding, Figma also needed to reduce and better control permission-related queries. ## Building a Custom Permissions DSL - Figma generally prefers adopting open-source or commercial solutions, but existing options did not adequately address its requirements. - The company chose to build: - A domain-specific language for expressing permissions - A custom cross-platform logic engine - A migration plan for moving critical permission rules into the new system - The intended result was a permissions system that improved developer ergonomics while increasing correctness and performance. Figma’s experience shows that permissions can become a foundational scalability and reliability problem when implemented as one growing authorization function. A dedicated, composable DSL can provide clearer rules, more flexible access models, and better control over database usage.

Read original(opens in new tab)
figma3 min readCurated summary

Behind the Feature: The Multiple Lives of Multi-Edit | Figma Blog

Multi-edit began as a way to reduce repetitive work when editing component variants, then evolved into a broader interaction model for editing matching objects across Figma designs. The feature addresses shortcomings in ordinary multi-selection, where selecting the right objects and applying certain edits—such as resizing or changing text—is difficult. After years of refinement, Figma launched multi-edit as a more natural, second-nature workflow. ## The Philosophy Behind Multi-Edit - The idea originated in 2019 during a design summit focused on Figma’s variants feature. - Designers noticed that editing variants required too much repetitive work. - The initial insight was to create a mode where one edit could apply simultaneously to all variants. - The team soon recognized that the same capability could help with many other design tasks. ### Why Existing Multi-Selection Wasn’t Enough - Figma already allowed users to select multiple objects, but the workflow had significant limitations: - Selecting exactly the objects users wanted to edit was difficult. - Some edits worked well across selections, while others did not. - Changing shared properties such as color, font, or font size was relatively easy. - More structural edits, including resizing multiple objects, were cumbersome. - Editing the actual text content of multiple text nodes was also difficult. ### A Long Period of Hibernation - Although the concept was sketched quickly, development did not begin immediately. - The team needed to resolve fundamental questions about how multi-edit should behave. - Early thinking treated it as a powerful, specialized mode similar to multi-select text editing in advanced text editors. - Refining the concept required reconciling that new mode with Figma’s existing selection model. ## Bringing Multi-Edit to Life - The finished feature lets users select and edit matching objects across frames and component sets. - Suggested interactions include: - `⌘ Command + ⌥ Option + A` to select all matching objects. - Shift-dragging to select specific matching objects. - Selecting multiple text objects and pressing Enter to edit their text together. - Selecting a component set and pressing `Q` to edit variants simultaneously. - Figma provides a playground file so users can experiment with these workflows. ## Knowing When It’s Ready - The article frames multi-edit as an example of a feature that required extensive iteration before feeling obvious. - Its goal was not merely to add a new command, but to make repetitive editing feel effortless and intuitive. - Figma’s broader product philosophy is to question established design-tool conventions when doing so can simplify everyday work. Figma’s experience suggests that seemingly simple, natural interactions often require substantial exploration. Multi-edit is most useful when users repeatedly update related objects, variants, or text, and its shortcuts can make those bulk edits significantly faster.

Read original(opens in new tab)
figma3 min readCurated summary

How We Engineer Feedback at Figma with Eng Crits | Figma Blog

Figma’s engineering critiques (“eng crits”) are designed to gather feedback early, before technical decisions become expensive to change. Unlike formal technical reviews, they are collaborative forums for exploration, brainstorming, and expert input—not approval gates. Figma found that using FigJam’s open canvas made it easier for many engineers to contribute and helped teams avoid late-stage, launch-blocking feedback. ## Why Early Feedback Matters - Engineers are encouraged to share in-progress work, including unpolished ideas and early technical directions. - Traditional technical reviews often happen after a design has already been developed, making feedback potentially disruptive or launch-blocking. - Eng crits occupy a middle ground between informal design critiques and formal technical reviews. - Their purpose is to help teams: - Explore novel approaches - Get expert feedback on technical designs - Unblock projects - Improve work through discussion rather than approval ## “Lifting Ideas Up” as Teams Scale - Early-stage teams often share ownership of both the overall architecture and its implementation. - As teams grow, newer contributors may be limited to executing established plans rather than shaping them. - Eng crits create a way for more people to contribute without undermining the original direction. - Figma CTO Kris Rasmussen emphasizes that eng crits are for soliciting feedback early and often, not for deciding whether work is approved. ## Why Format Matters - Synchronous technical reviews tended to focus discussion on a few team leads. - Asynchronous reviews often produced long, disconnected comment threads rather than meaningful conversations. - Figma drew inspiration from brainstorms and retrospectives conducted in FigJam. - FigJam enabled participants to: - Contribute simultaneously - Share early thinking and inspiration - Add screenshots of unfinished work - Provide context and prompts - Offer feedback without waiting for a single presenter or responding through fragmented threads ## Scaling the Practice - Figma initially piloted eng crits with teams of roughly eight to ten people. - The collaborative format quickly gained support and was turned into a repeatable process. - Calendar invitations were later opened to a much broader audience, eventually attracting more than 200 participants. - Engineers were encouraged to join when they had relevant expertise or curiosity, rather than treating attendance as mandatory. ## Anatomy of an Eng Crit - Figma sends invitations to all engineers working on the editor. - Invitees are marked as optional so they can participate when a topic is relevant or opt out when it is not. - Cross-functional collaborators may also attend. - Participation is driven by relevance and interest, rather than by a formal approval hierarchy. Figma’s experience suggests that technical feedback works best when it is early, inclusive, and explicitly separated from approval. Teams can adopt a similar model by using a shared visual workspace, inviting contributors broadly, and framing reviews as opportunities to improve ideas rather than gates that determine whether work may proceed.

Read original(opens in new tab)
figma2 min readCurated summary

Nicole Boettcher’s Figma-Designed Quilts | Figma Blog

Nicole Boettcher, a former product designer, uses Figma to design and plan her quilts. Her UX background leads her to carefully map patterns, colors, measurements, and sewing steps before cutting fabric. Figma helps her iterate quickly, reduce waste, and translate digital layouts into precise handmade pieces. ## From Product Design to Quilting - During the pandemic in 2021, Nicole left product design at Artsy and began learning to quilt. - She taught herself through online tutorials and beginner patterns. - As her projects grew more ambitious, she turned to Figma to create original designs. - She designs roughly 80% of each quilt digitally before cutting any fabric. ## Building Designs in Figma - Nicole often starts with a traditional quilt block and experiments with its shapes, colors, and proportions. - She maintains a Figma color library using swatches from fabric manufacturers. - Existing fabric supplies influence her palette and pattern choices. - Figma makes it easy to recolor sections, adjust layouts, and create many variations. - Plugins such as Random Colors Fill help her explore different palettes. - Auto layout allows her to move or modify entire rows of a quilt grid at once. ## Planning Fabric and Construction - Once a design is finalized, Nicole duplicates it and breaks it into individual pieces. - The Count Things plugin helps calculate quantities, such as the number of rectangles and squares required. - Pixels in her Figma files correspond to inches in the physical quilt. - She plans cuts carefully to minimize scraps and use fabric efficiently. - She adds a quarter-inch seam allowance to each side of every piece before estimating fabric requirements. - She also rearranges pieces digitally to determine an efficient sewing sequence and reduce unnecessary steps. ## Inspiration and Influences - Nicole draws inspiration from quilting books and artists on Instagram. - She recommends exploring Amish quilts and Gee’s Bend quilts. - Favorite sources include accounts focused on vintage quilts and contemporary textile artists. Figma gives Nicole a bridge between digital product design and physical craft: it lets her experiment freely while preserving the precision quilting requires. For complex, material-intensive projects, digitally planning patterns and construction can save both time and fabric.

Read original(opens in new tab)
figma2 min readCurated summary

Behind the Feature: Inline Device Frames | Figma Blog

Inline device frames bring interactive phone, tablet, and watch mockups directly into the Figma editor, making prototypes feel closer to real-world use without switching to presentation view. The feature evolved from Figma’s inline preview and was designed to make devices tangible, movable, and resizable. Its development balanced realistic device representation with intuitive interactions and collaborative input from Figma’s community and cross-functional teams. ## Prototyping in the Editor - Figma introduced inline device frames as part of broader prototyping improvements. - Designers can preview their work within representations of mobile, tablet, and watch devices. - The goal is to help teams identify usability gaps and opportunities earlier by experiencing how designs actually behave. - Other announced prototyping updates included: - Copying and pasting interaction “noodles” - Faster flow deletion - Importing elements with local variables into new files - A 22% reduction in loading-spinner time in key use cases ## A Collaborative Foundation - Figma previously offered device presets in presentation view, but the team wanted to make them available beside designs in the editor. - The intended experience was for devices to feel tangible: - Users should be able to grab, move, and resize them. - Frames needed to be dynamic and responsive rather than static images. - Development combined community research with feedback from engineering, design, product management, and marketing teams. - Three guiding principles shaped the feature: - Seamless integration into the design process - Realistic representation of diverse devices - Intuitive interactions through clearly defined hit targets ## Representing Different Devices - The inline preview’s space constraints led the team to prioritize phones, tablets, and watches rather than larger personal-computer interfaces. - Supporting many device shapes and sizes created significant design and engineering challenges. - The team had to account for details such as smartphone notches, which house front-facing cameras and sensors. - Watch frames raised additional questions about where users should be able to interact and resize the device. Inline device frames are intended to make prototyping more immediate and realistic while preserving the flexibility of the Figma editor. Designers can use them to evaluate designs in context without leaving their working file.

Read original(opens in new tab)
figma2 min readCurated summary

David Hoang on how AI brings design and development together | Figma Blog

AI is reshaping creative tools by making interfaces more dynamic, multimodal, and less fully controlled by designers. David Hoang argues that design and engineering are converging as AI augments both disciplines, enabling more people to move from learning and prototyping to shipping real products. Replit’s focus is “Artificial Developer Intelligence” (ADI), aimed at increasing autonomy, productivity, and collaboration rather than pursuing general intelligence. ## Dynamic Interfaces and a New Design Paradigm - Like the rise of mobile, AI is resetting the field and giving designers an opportunity to rethink how people interact with technology. - Interfaces will increasingly adapt across modalities and form factors instead of presenting a fixed, fully designed experience. - Designers must relinquish some control over presentation while shaping how systems behave and respond. - AI, spatial computing—including Apple Vision Pro—and other emerging technologies are converging to create new interaction models. ## Design and Engineering Converge - AI can augment both designers and engineers, making the boundaries between the disciplines less distinct. - Product development is evolving toward a tightly integrated design-and-engineering practice. - Replit frames this strategy as Artificial Developer Intelligence, or ADI, rather than Artificial General Intelligence. - ADI is intended to give people greater autonomy and productivity through collaboration between humans and AI. ## Replit’s Vision for Artificial Developer Intelligence - Future ADI agents could: - Generate code and complete code automatically. - Build complex software architectures. - Orchestrate advanced tools deployed on Replit. - Understand how teams work and improve organizational collaboration. - Hoang describes Replit as a potential “technical co-founder” for people with ideas but limited technical expertise. - The goal is to accelerate the path from learning to coding, launching a business, and scaling an idea. ## Lowering the Barrier to Building Software - AI-powered tools can enable nontechnical users to create technically sophisticated applications. - A Replit hackathon example showed a nontechnical product manager producing work that surpassed projects built by teams of engineers. - Prompting becomes an important skill because translating goals into effective instructions resembles the product manager’s role in defining what should be built. AI’s practical impact may be greatest when it helps people combine product judgment, design, and engineering execution. Rather than replacing creative or technical roles, tools like ADI are positioned to expand who can build software and shorten the distance between an idea and a working product.

Read original(opens in new tab)
datadogOriginal article

How we use Vale to improve our documentation editing process | Datadog (opens in new tab)

To manage a high volume of technical content across dozens of products, Datadog’s documentation team has automated its editorial process using the open-source linting tool Vale. By integrating these checks directly into their CI/CD pipeline via GitHub Actions, the team ensures prose consistency and clarity while significantly reducing the manual burden on technical writers. This "shift-left" approach empowers both internal and external contributors to identify and fix style issues independently before a formal human review begins. ### Scaling Documentation Workflows * The Datadog documentation team operates at a 200:1 developer-to-writer ratio, managing over 1,400 contributors and 35 distinct products. * In 2023 alone, the team merged over 20,000 pull requests covering 650 integrations, 400 security rules, and 65 API endpoints. * On-call writers review an average of 40 pull requests per day, necessitating automation to handle triaging and style enforcement efficiently. ### Automated Prose Review with Vale * Vale is implemented as a command-line tool and a GitHub Action that scans Markdown and HTML files for style violations. * When a contributor opens a pull request, the linter provides automated comments in the "Files Changed" tab, flagging long sentences, wordy phrasing, or legacy formatting habits. * This automation reduces the "mental toll" on writers by filtering out repetitive errors before they reach the human review stage. ### Codifying Style Guides into Rules * The team transitioned from static editorial guidelines stored in Confluence and wikis to a codified repository called `datadog-vale`. * Style rules are defined using Vale’s YAML specification, allowing the team to update global standards in a single location that is immediately active in the CI pipeline. * Custom regular expressions are used to exclude specific content from validation, such as Hugo shortcodes or technical snippets that do not follow standard prose rules. ### Implementation of Specific Linting Rules * **Jargon and Filler Words:** A `words.yml` file flags "cruft" such as "easily" or "simply" to maintain a professional, objective tone. * **Oxford Comma Enforcement:** The `oxfordcomma.yml` rule uses regex to identify lists missing a serial comma and provides a suggestion to the author. * **Latin Abbreviations:** The `abbreviations.yml` rule identifies terms like "e.g." or "i.e." and suggests plain English alternatives like "for example" or "that is." * **Timelessness:** Rules flag words like "currently" or "now" to ensure documentation remains relevant without frequent updates. By open-sourcing their Vale configurations, Datadog provides a framework for other organizations to automate their style guides and foster a more efficient, collaborative documentation culture. Teams looking to improve prose quality should consider adopting a similar "docs-as-code" approach to shift editorial effort toward the beginning of the contribution lifecycle.

datadog3 min readCurated summary

How we use Vale to improve our documentation editing process

Datadog’s Documentation team uses automated style linting to maintain clear, consistent prose across a large, fast-moving documentation repository. By integrating the open-source Vale linter into local authoring workflows and GitHub Actions, the team moves copy editing closer to the moment content is written. This reduces review effort, helps contributors fix issues themselves, and makes the team’s style guide executable rather than scattered across multiple documents. ## Documentation at Scale - The Documentation team grew from 7 to 14 writers while supporting roughly 200 developers per writer. - The repository includes documentation for 35 products and more than 1,400 internal and external contributors. - In 2023, the team merged more than 20,000 pull requests covering: - 30+ products - 65 API endpoints - 95 Marketplace integrations - 400 security compliance rules - 400 workflow actions - 650 integrations - An on-call writer reviews more than 40 pull requests per day, making automated consistency checks especially valuable. ## Why Manual Style Enforcement Falls Short - Writers must catch issues such as: - Jargon and wordy phrasing - Malapropisms - Mismatched tenses - Gendered language - Typewriter-era formatting habits - Organization-specific preferences - Contributors and AI writing tools may not know Datadog’s conventions, such as using serial commas, avoiding “via,” or eliminating time-sensitive words like “currently.” - Previously, style guidance had to be maintained in Confluence, review documentation, contributing guides, and repository wiki pages. ## Vale in Authoring and CI - Datadog adopted Vale, an open-source command-line prose linter, through the `datadog-vale` project. - A GitHub Action runs Vale against Markdown and HTML files in pull requests. - The repository’s `vale.ini` file identifies: - Where style rules are stored - Which rules should run - Which content formats should be checked - Automated comments appear in GitHub’s **Files Changed** view, allowing contributors to correct issues before a writer reviews the pull request. - Vale has reduced editing time and the mental burden on writers while improving contributor self-service. ## Turning the Style Guide into Rules - Existing editorial guidelines were converted into YAML-based Vale rules. - New rules can be added once and enforced everywhere, avoiding duplicated documentation. - Regular expressions exclude content that should not be linted, such as Hugo shortcodes. - Rules can identify both broad writing problems and precise organizational preferences. ## Examples of Vale Rules - A `words.yml` file can flag unnecessary jargon or “cruft” such as “easily” and “simply.” - An `oxfordcomma.yml` rule detects sentences that omit the Oxford comma and provides a correction message and link to the relevant style guidance. - An `abbreviations.yml` rule replaces Latin abbreviations with plain-English alternatives: - `e.g.` → “for example” - `i.e.` → “that is” - `etc.` → “and more” - Vale rules can define severity levels such as `suggestion` or `error`, include explanatory messages, link to documentation, and optionally perform replacements. Datadog’s approach demonstrates that documentation quality can be improved by treating prose standards like code standards: encode them as rules, run them continuously, and give authors immediate, actionable feedback. Teams with large contributor bases can use Vale and CI to make their style guide consistent, discoverable, and easier to maintain.

Read original(opens in new tab)
figma2 min readCurated summary

5 Things Designers Need to Know for a Smooth Handoff | Figma Blog

Design handoff should be treated as an ongoing process of communication and collaboration, not a single event at the end of design. The article argues that clear annotations, shared terminology, and organized files help ensure that “Ready for dev” genuinely means developers have the context they need. These practices reduce ambiguity while preserving conversations between designers and developers. ## Streamline and Clarify Callouts - Use annotations to explain design intent and highlight details that might otherwise be missed. - Focus callouts on information developers actually need, such as: - New components - Specific interactions not obvious from a prototype - Platform-specific differences - Specs, measurements, and behavior - Avoid duplicating information already captured through variables or styles. - Figma’s annotations in Dev Mode can pin measurements, properties, and notes directly to designs. - Annotations are intended to improve—not replace—designer-developer discussions. ## Adopt a Shared Language - Design and development may use different terms for similar concepts, so teams should align on naming early. - Clarify terms such as “toggle” or “switch” to avoid misunderstandings. - Coordinate variable, style, and component names with conventions already used in code. - Use variables and styles for foundational properties such as: - Fonts - Colors - Spacing - Shared names like `bg-primary-active` are more reliable than manually communicating hex codes or font specifications. - A color wheel within the design system can help teams consistently reference shades and tints. ## Organize Files with Labels - Infinite canvases can become difficult for developers to navigate, especially when they contain unfinished explorations. - Clean up and structure files before inviting developers to build. - Use sections to group related designs and reduce navigation overhead. - Mark completed sections or frames with a “Ready for dev” status so developers know where to focus. - Standardized team templates can reduce context switching and create a more predictable handoff process. A smooth handoff depends on shared context, precise communication, and intentional file organization. Designers should tailor annotations and terminology to their development partners, then clearly separate exploratory work from implementation-ready designs.

Read original(opens in new tab)
datadog2 min readCurated summary

.NET Continuous Profiler: CPU and wall time profiling | Datadog

Datadog’s page announces that the company was named a Leader in Gartner’s 2026 Magic Quadrant for Observability Platforms. The provided content mainly consists of Datadog’s product navigation, showing the breadth of its observability, security, digital experience, software delivery, and AI offerings; it does not include the blog article’s substantive text. ## Gartner Recognition - Datadog highlights its position as a Leader in the **Gartner Magic Quadrant for Observability Platforms 2026**. - The page links to a resource describing this recognition. ## Datadog’s Platform Coverage - **Infrastructure:** infrastructure, container, network, serverless, cloud cost, storage, and GPU monitoring. - **Applications:** APM, universal service monitoring, continuous profiling, dynamic instrumentation, and agent observability. - **Data and logs:** database monitoring, data-stream monitoring, log management, sensitive-data scanning, and observability pipelines. - **Security:** code, cloud, workload, application, API, SIEM, vulnerability, compliance, and entitlement management. - **Digital experience:** browser and mobile RUM, session replay, synthetic monitoring, product analytics, experiments, and error tracking. - **Software delivery and service management:** CI visibility, test optimization, feature flags, incident response, SLOs, workflow automation, and case management. - **AI capabilities:** AI agents, investigation tools, GPU monitoring, integrations, MCP services, and AI-assisted development. The supplied excerpt supports the conclusion that Datadog is presenting Gartner’s recognition as validation of its broad, integrated observability platform. A detailed technical summary would require the full blog post, which is not included here.

Read original(opens in new tab)
datadog3 min readCurated summary

.NET Continuous Profiler: CPU and wall time profiling

Datadog’s .NET profiler uses low-overhead thread sampling to collect CPU and wall-time profiles suitable for production. CPU profiling measures time spent running on a processor, while wall-time profiling captures delays caused by I/O, locks, or scheduling. The implementation tracks managed threads, walks their stacks, aggregates samples, and periodically uploads profiles, with platform-specific optimizations for Windows and Linux. ## CPU and Wall-Time Profiling - CPU profiling identifies code consuming processor cycles. - Wall-time profiling finds slow methods regardless of whether threads are running, blocked, or waiting for I/O. - ETW, Linux `perf`, and .NET enter/leave hooks provide profiling data but impose too much overhead or require elevated privileges. - Datadog instead samples threads at intervals, captures their call stacks, and assigns durations to the samples. ## Managed Thread Sampling - The profiler tracks managed threads created through: - The thread pool - `Task` and `async/await` - Explicit `Thread` instances - `ICorProfilerCallback` notifications such as `ThreadCreated` and `ThreadDestroyed` maintain the `ManagedThreadList`. - `StackSamplerLoop` captures stacks and sends raw samples to `CpuTimeProvider` and `WallTimeProvider`. - `SamplesCollector` aggregates provider data, while a shared Rust exporter uploads profiles to Datadog every minute. - An early C# implementation caused native worker threads entering managed code to appear as application threads. Removing that implementation eliminated accidental self-sampling. ## Native Runtime Threads - Server-mode garbage collection uses native threads that can compete with application threads for CPU. - Because the .NET profiling API does not expose these threads directly, the profiler identifies them by their .NET 5 names: - `.NET Server GC` - `.NET BGC` - Their CPU usage is displayed under a Garbage Collector frame in the flame graph. ## CPU Sampling and Performance Optimizations - Every 10 milliseconds, the profiler searches for runnable managed threads, skipping up to 64 non-runnable threads. - `IsRunning` determines whether a thread is executing on a CPU: - Windows uses `NtQueryInformationThread`. - Linux reads `/proc/self/task/<tid>/stat`. - CPU sample duration is calculated from the difference between the thread’s current and previously recorded CPU consumption. - The initial Linux implementation used `std::ifstream` and `std::getline`, allocating an 8 KB buffer for each sample. - Replacing them with lower-level C file-reading code eliminated allocations and reduced CPU usage. The original approach consumed nearly 500 MB of allocations and about 2% of total CPU in testing. ## Wall-Time Profiling and Code Hotspots - Wall-time profiles work with Datadog tracing to explain why requests are slow. - The tracer provides the profiler with a span ID when a thread handles a request. - To avoid repeated expensive P/Invoke calls, the profiler exposes a memory location that the tracer can update directly. - Because short requests may finish before their thread is sampled, the profiler samples an additional group of ten span-associated threads beyond the initial five. - The duration between consecutive samples of a thread is attributed to the later sample, so heavily threaded applications produce longer individual wall-time sample durations.

Read original(opens in new tab)