The post presents memorable Config talks as a source of inspiration and a practical rubric for future speakers. Its central lesson is that standout presentations challenge conventional thinking, tell a personal story, and show genuine care for the people affected by the work. The excerpt focuses on taking creative risks rather than blindly following industry best practices.
## Taking Risks and Rejecting Convention
- Josh Wardle’s talk, **“Opting for the opposite,”** explains how he created Wordle by deliberately ignoring common growth tactics.
- Wordle:
- Could be played only once per day.
- Did not link back to the game when shared.
- Was built as a personal gift for Wardle’s partner, not as a viral product.
- The talk resonated with Config speakers because it demonstrates that:
- Simplicity can outperform metrics-driven optimization.
- Conventional wisdom is not always appropriate for a specific audience.
- Building with deep care for users can matter more than maximizing engagement.
- The broader message is to show how a meaningful product decision emerged from a willingness to do things differently.
## Creating an Inspirational Presentation
- The article frames memorable talks as more than informational sessions: they should change assumptions and leave audiences thinking differently.
- Other referenced Config sessions include:
- **“An Infinite Canvas,”** by Linda Dong and Mike Stern, about spatial-computing design.
- A discussion between George Kedenburg III and Humane co-founder Imran Chaudhri about the development and vision of the Ai Pin.
- These examples suggest that strong talks combine:
- A distinctive perspective.
- A compelling story about the work.
- Clear attention to users and real-world impact.
When preparing a Config talk—or any presentation—focus on a genuine insight or unconventional decision, explain the reasoning behind it, and connect it to the people you are building for.
Global Accessibility Awareness Day highlights the importance of building inclusive digital products. The post recommends integrating accessibility testing throughout development using Accessibility Insights for Web and Visual Studio’s Integrated Accessibility Checker. Combining automated scans with manual testing helps developers identify both common and deeper accessibility problems.
## FastPass for Rapid Automated Testing
- Accessibility Insights for Web uses axe-core to detect common, high-impact accessibility issues.
- FastPass can identify problems in under five minutes, often revealing failures within a couple of minutes.
- Developers can use it while writing UI code to find and fix issues early.
- The tool also includes WCAG 2.2 guidance and testing support in its Assessment feature.
## Visual Studio’s Integrated Accessibility Checker
- Available since Visual Studio 2022 version 17.5, the checker scans desktop applications within the IDE.
- It detects common accessibility issues and reports them directly in Visual Studio.
- The feature is powered by the Axe-Windows engine, also used by Accessibility Insights for Windows.
## Manual Testing with Quick Assess
- Automated tools cannot detect every accessibility issue, so manual inspection remains necessary.
- Quick Assess provides 10 assisted tests for issues beyond automated detection.
- Tests include explanations of why each issue matters, along with remediation resources and examples.
- Examples include checking heading levels and reviewing individual instances for easier validation.
## Building Accessibility into Development
- Accessibility testing should be part of the product life cycle rather than a final checklist.
- Developers can use FastPass’s Tab Stops test to evaluate keyboard navigation and focus order.
- Poor focus order can make interfaces difficult to use for people relying on screen readers, magnifiers, or those with reading disorders.
- Small, consistent testing practices can significantly improve the experience for users with disabilities.
The recommended approach is to start with automated checks, supplement them with Quick Assess and keyboard-based manual testing, and continue improving accessibility throughout development.
Razorpay built Blade, a cross-platform design system, to create consistent, accessible experiences across its many products while accelerating collaboration between designers and developers. Its success depends not only on reusable components, but also on adoption metrics, advocacy, developer tooling, and tight integration between design and code. Tools such as Blade Coverage, RazorSharp, Dev Mode, Storybook links, and Figma variables have significantly reduced handoff friction and improved productivity.
## Blade’s Cross-Platform Structure
- Razorpay has around 70 designers and 100 front-end developers.
- Three designers and five engineers work full-time on Blade.
- Blade supports desktop web, mobile web, iOS, and Android through a shared API and common properties.
- This allows developers to transfer knowledge between platforms without rebuilding the system for each one.
## Problems Blade Solved
- Before Blade, teams frequently hard-coded custom components and missed details such as:
- Button states
- Text-field error handling
- Accessibility requirements
- Repetitive, ad hoc development led to inconsistent user experiences across Razorpay’s products and domains.
- Blade provides:
- A shared design and development language
- More consistent experiences across products
- Built-in accessibility
- Faster collaboration and shorter time to market
- Designers and developers are treated as Blade’s customers, while end users benefit from the resulting consistency and reliability.
## Driving Design System Adoption
- Razorpay uses several strategies to reduce adoption friction:
- Securing leadership support for funding and organizational adoption
- Tracking metrics such as onboarded projects and the percentage of apps using Blade components
- Holding office hours and maintaining a support Slack channel
- Creating an advocacy group of designers from consumer teams
- Announcing new components through demo videos and status-page updates
- These practices make Blade visible, supported, and easier for individual teams to adopt.
## Measuring Impact and Coverage
- Blade’s north star is enabling teams to ship polished interfaces while the system handles common design and implementation work.
- Its adoption targets are:
- 70% Blade usage for new features
- 50% usage for existing product surfaces
- Razorpay discovered that adoption begins during design, not just development.
- The Blade Coverage plugin shows designers where their designs diverge from Blade components, helping them:
- Identify issues earlier
- Predict launch timelines more accurately
- Reduce handoff friction
- Quantitative metrics are supplemented with surveys and focus groups measuring speed, documentation, training, collaboration, and user experience.
- These findings contribute to an annual Net Promoter Score for the design system.
## RazorSharp and Improved Developer Handoffs
- Before Dev Mode, developers had to inspect designs manually, identify components and properties, and reproduce them in code.
- A developer created RazorSharp as a private plugin that automatically generated equivalent code for designs.
- Initially, Figma required edit access to run plugins, forcing developers to clone shared files before using RazorSharp.
- When Figma introduced Dev Mode, Razorpay adapted RazorSharp to work there in just two days.
- Developers can now inspect designs and generate implementation code without editing or duplicating files.
- Dev Mode also includes links to Storybook, allowing developers to move directly from a design component to its code playground.
## Variables and Design Tokens
- Razorpay is transitioning its design tokens to Figma variables.
- This makes token copying more seamless and supports developer-friendly naming such as `surface.text.subtle`.
- Spacing tokens are now mapped to variables, addressing a frequent request from consuming teams.
- Variables make light and dark modes easier to implement without duplicating entire designs.
- Previously, multiple themes and modes caused Blade files to consume large amounts of memory and slowed designers down.
- Consolidating Blade into a single theme with variables has substantially improved design performance.
Razorpay’s approach shows that a design system is most effective when it is treated as an internal product: it needs leadership support, measurable adoption goals, user support, and tooling that connects design directly to implementation. Teams building similar systems should invest in both component quality and the workflows that make those components easy to discover and use.
Datadog’s Frontend Developer Experience team migrated their massive codebase from a fragile, custom Puppeteer-based acceptance testing framework to Datadog Synthetic Monitoring to address persistent flakiness and high maintenance overhead. By leveraging a record-and-play approach and integrating it into their CI/CD pipelines via the `datadog-ci` tool, they successfully reduced developer friction and improved testing reliability for over 300 engineers. This transition demonstrates how replacing manual browser scripting with specialized monitoring tools can significantly streamline high-scale frontend workflows.
### Limitations of Puppeteer-Based Testing
* Custom runners built on Puppeteer suffered from inherent flakiness because they relied on a complex chain of virtual graphic engines, browser manipulation, and network stability that frequently failed unexpectedly.
* Writing tests was unintuitive, requiring engineers to manually script interaction details—such as verifying if a button is present and enabled before clicking—which became exponentially more complex for custom elements like dropdowns.
* The testing infrastructure was slow and expensive, with CI jobs taking up to 35 minutes of machine time per commit to cover the application's 565 tests and 100,000 lines of test code.
* Maintenance was a constant burden; every product update required a corresponding manual update to the scripts, making the process as labor-intensive as writing new features.
### Adopting Synthetic Monitoring and Tooling
* The team moved to Synthetic Monitoring, which allows engineers to record browser interactions directly rather than writing code, significantly lowering the barrier to entry for creating tests.
* To integrate these tests into the development lifecycle, the team developed `datadog-ci`, a CLI tool designed to trigger tests and poll result statuses directly from the CI environment.
* The new system uses a specific file format (`.synthetics.json`) to identify tests within the codebase, allowing for configuration overrides and human-readable output in the build logs.
* This transition turned an internal need into a product improvement, as the `datadog-ci` tool was generalized to help all Datadog users execute commands from within their CI/CD scripts.
### Strategies for High-Scale Migration and Adoption
* The team utilized comprehensive documentation and internal "frontend gatherings" to educate 300 engineers on how to record tests and why the new system required less maintenance.
* To build developer trust, the team initially implemented the new tests as non-blocking CI jobs, surfacing failures as PR comments rather than breaking builds.
* Migration was treated as a distributed effort, with 565 individual tests tracked via Jira and assigned to their respective product teams to ensure ownership and a steady pace.
* By progressively sunsetting the old platform as tests were migrated, the team managed a year-long transition without disrupting the daily output of 160 authors pushing 90 new PRs every day.
To successfully migrate large-scale testing infrastructures, organizations should prioritize developer trust by introducing new tools through non-blocking pipelines and providing comprehensive documentation. Transitioning from manual browser scripting to automated recording tools not only reduces technical debt but also empowers engineers to maintain high-quality codebases without the burden of managing complex testing infrastructure.
Digital design has gained formal recognition as a distinct profession, reflecting its growing importance to businesses and everyday life. The U.S. Bureau of Labor Statistics now separately tracks “web and digital interface designers” and projects nearly 40% growth in the broader category through 2030. This change confirms a global surge in demand driven by the increasing importance of digital products, subscriptions, and user engagement.
## Formal Recognition of Digital Design
- The BLS previously grouped digital designers with web developers or did not track them separately.
- Its new category recognizes web and digital interface design alongside established fields such as graphic, industrial, interior, and architectural design.
- The broader web development and digital design category is projected to grow from 2020 to 2030 by almost 40%.
- Projections for 2030 increased from 188,000 jobs before the pandemic to 225,000 by February 2022.
## Demand Is Growing Globally
- Design recruiter Judy Wert describes demand for designers as unprecedented, with company inquiries reportedly tripling in recent years.
- LinkedIn identified design and UX research as fast-growing job categories across countries including the UK, France, Germany, Poland, Spain, Brazil, Saudi Arabia, and India.
- Figma’s survey of 280 enterprise companies in four countries found that design teams grew by an average of 31% between 2019 and 2022.
## Why Businesses Need More Designers
- People increasingly depend on digital interfaces for essential activities, including banking, work, healthcare, entertainment, education, and personal planning.
- Many companies now operate through subscriptions or user engagement, making retention and satisfaction critical.
- Frequent product updates and rapidly changing user expectations require organizations to respond quickly to feedback.
- Design therefore influences not only how products look, but also how companies compete, retain customers, and operate.
- Design thinking and initiatives such as Stanford’s d.school have made design methods more accessible across organizations, reducing resistance to design work.
Digital design’s recognition by the BLS is less a symbolic change than evidence of a broader business transformation. Organizations should treat design as a core strategic capability and continue investing in designers who can shape effective, adaptable digital products.
Tekeste Kidanu, known online as tk made it, builds Figma and FigJam plugins that address practical needs from the design community. His best-known project, SPELLL, provides grammar and spell checking inside design files, while his newer FigJam tools support note-taking, color customization, and voting. He credits community feedback, Figma’s approachable plugin API, and his interest in design for shaping his work.
## Background and Motivation
- Tekeste is an introverted frontend developer who moved to the U.S. in 2016 to study computer science.
- He became interested in improving his design skills, particularly in color theory and typography.
- He contributes to the Figma Community by creating tools that help designers work more productively.
## SPELLL: Spell Checking for Figma and FigJam
- SPELLL scans Figma and FigJam documents for spelling and grammar errors.
- Users can correct mistakes directly, similar to using Grammarly.
- The plugin aims to save designers time and prevent embarrassing typos during presentations.
- Tekeste developed the idea after seeing requests on the Figma Forum, Designer News, Twitter, and other design communities.
## Learning the Figma Plugin API
- Tekeste researched how the plugin should work before beginning development.
- He taught himself the Figma plugin API through its documentation and questions in the Figma Plugins Slack workspace.
- He was surprised by how easy it was to begin, finding that his existing JavaScript and web-development knowledge provided a strong foundation.
## Building for FigJam
- When FigJam introduced plugin support, Tekeste began adapting his existing Figma tools.
- The similar APIs and development processes for Figma and FigJam made migration straightforward.
- His FigJam projects include:
- **Notes**, a widget for storing detailed plain-text or Markdown notes without cluttering a board.
- **Color Picker**, which adds custom-colored stickies and shapes.
- **Voting**, which supports anonymous and non-anonymous voting sessions.
## Community-Driven Inspiration
- Tekeste frequently finds ideas in feature requests and discussions on Twitter, the Figma Forum, and Friends of Figma Slack.
- He notes that many requested features can be implemented through the plugin API before Figma adds them natively.
- He hopes another developer will build a FigJam widget showing what music participants are listening to.
## Looking Ahead
- Tekeste plans to improve his voting widget and make it the best possible tool for FigJam sessions.
- He is excited about the public release of FigJam plugins and widgets and the creativity it may encourage.
- He is also inspired by the growing popularity of playful, animated, and interactive interfaces, citing Apple Maps and the Honk app as examples.
Figma’s open plugin and widget platform gives developers like Tekeste a practical way to turn community requests into useful design tools. His work demonstrates how existing web skills, combined with active listening to users, can produce focused improvements to collaborative workflows.
Maël Nison’s journey from learning DarkBASIC on La Réunion and in Toulouse to becoming Yarn’s principal maintainer illustrates how curiosity, open source, and a focus on solving practical problems can shape a career. His early experimentation with games, websites, forums, and content-management systems developed into a lasting interest in improving developer workflows. That path eventually led through EPITECH, startups, Facebook, and Datadog, while giving him broad experience across both software and community leadership.
## Early Programming on La Réunion and in Toulouse
- Maël grew up on the remote Indian Ocean island of La Réunion, where he had little access to computers.
- After moving to Toulouse, he discovered a school programming club and began creating games with DarkBASIC.
- DarkBASIC simplified 2D and 3D Windows game development through built-in libraries, tutorials, and DirectX support.
- Seeing code immediately produce something on screen made programming feel logical and compelling to him.
- By high school, he was building PHP websites, working with SQL, and experimenting with multiple languages and platforms.
## Discovering Open Source and Workflow Automation
- In the early 2000s, distributing software was much harder because platforms such as GitHub did not yet exist.
- Maël shared source archives through online forums, reflecting the informal nature of early open source communities.
- His interest in forum software led to work on content-management systems.
- He focused on reducing repetitive administrative workflows, such as allowing users to edit content directly instead of navigating through multiple administration pages.
- This pattern—identifying a problem, building a solution, and sharing it with others—became a central theme in his career.
## Education at EPITECH
- Maël attended EPITECH in Paris, an institution centered on practical technical education and self-directed learning.
- The school emphasized peer assessment and hands-on projects rather than traditional, theory-heavy instruction.
- He also spent a year abroad in Québec.
- During his final year, he combined his studies with his first full-time job, gaining professional experience before graduation.
## Joining Facebook and Yarn
- In 2017, after several years in startups, Maël moved from France to London seeking opportunities at larger organizations.
- He joined Facebook without specifically intending to work on a package manager.
- Facebook’s onboarding “boot camp” identified his skills and connected him with the emerging Yarn project.
- He welcomed the opportunity to work on open source during his regular working hours.
- What began as a few pull requests became a multi-year role as a major maintainer and leader of the project.
## Yarn’s Technical and Community Evolution
- Yarn was rewritten in TypeScript and re-architected into a more modular system.
- It evolved from an internal Facebook tool into a genuinely community-driven open source project.
- Maël’s responsibilities expanded far beyond coding:
- Product management and roadmap planning
- Team leadership and infrastructure
- Customer support and community work
- Web design, evangelism, and outreach
- Defining the project’s broader vision
- Although he left Facebook for Datadog in 2019, he continued leading Yarn while taking on new challenges at Datadog.
Maël’s experience suggests that careers can grow from small, self-directed experiments into major technical leadership opportunities. Developers can follow a similar path by solving concrete problems, sharing their work openly, and being willing to take on the technical, organizational, and community responsibilities that accompany successful projects.
The post argues that choosing a first job should involve more than checking boxes such as “interesting problems,” “smart people,” and “good culture.” Josh Shi reflects on joining Figma as a new graduate and encourages readers to examine how work fits into their broader lives, interests, and changing goals. His conclusion is that the most useful job-search framework is built around personal questions rather than universal criteria.
## Rethinking Work-Life Balance
- Work and life are not opposing forces in a zero-sum equation.
- The hours spent working and not working together constitute a person’s life, and each affects the other.
- Job satisfaction can influence life outside work, just as personal circumstances can affect satisfaction at work.
- Measuring balance only by the number of hours worked ignores the nature and meaning of the work.
- The author acknowledges that treating work as a career is a privilege, especially during economic hardship or when employment is uncertain.
- People who have the opportunity to choose should ask:
- What kinds of work interest me?
- Does this workplace support those interests?
- Will I be able to learn and develop?
- Can the role adapt as my interests change?
- What skills or crafts can I build?
- Does the job leave room for other interests?
## Learning as a New Graduate
- At Figma, Shi gained new technical experience, including:
- Full-stack development
- Writing C++ for the web
- More significantly, he learned to own features and participate in the full product-development process.
- This included scoping projects, clarifying ambiguous goals, and taking ideas from inception through launch.
- Mentorship and support from colleagues made it possible for him to challenge himself and take ownership.
- The same people he met during his interview continued to provide guidance and expertise after he joined.
## Company Growth and Change
- Figma had changed substantially during Shi’s first few years as the company and product expanded.
- The company began transitioning toward a hybrid model, illustrating that workplaces evolve over time.
- This reinforces the importance of considering not only whether a company fits current interests, but also whether it can accommodate future growth and changing priorities.
Design systems should provide consistency and speed without becoming rigid constraints. Shopify, Condé Nast, and Harry’s emphasize flexible architectures, brand-specific tokens, continuous iteration, and strong connections between design and code. The most effective system is one that adapts to changing needs while remaining simple enough for teams to use.
## Flexibility Over Rigidity
- Overly prescriptive rules can limit creativity and push designers outside the system.
- Harry’s uses layered architecture:
- Base components offer simple, low-complexity solutions.
- More advanced layers, such as starter kits, support custom work.
- This approach makes the standard path efficient while preserving room for exploration.
- Condé Nast uses modular components and design tokens to support brands such as *Vogue*, *The New Yorker*, and *Bon Appétit*.
- A token can represent the same purpose while holding different values—for example, “prominent text” can map to a different font for each brand.
## Design Systems Must Evolve
- Building a system is only the beginning; teams must observe how it performs in real use.
- Analytics and usage data help identify which libraries and components are being used and where changes are needed.
- Shopify aims to create systems that “bend but not break,” rather than polished artifacts that teams are afraid to modify.
- Teams should watch how the system fails—including how it affects end users—in order to improve and reinvent it.
## Connecting Design to Code
- Translating design components into code improves efficiency and reduces friction between designers and engineers.
- Condé Nast stores its token system in JSON and uses a custom plugin to import and export token changes.
- This setup helps the company launch new markets quickly while maintaining a smooth design-to-development handoff.
- Even teams without multiple brands can start by associating a purpose with each value, such as naming a color or typography style by its intended use.
- Purpose-based naming exposes unnecessary complexity and makes systems easier to evaluate.
## A System Designed for the Team
- There is no universal design-system model.
- The right structure depends on a team’s size, organization, technical environment, and priorities.
- Systems should establish useful foundations while leaving enough flexibility for different products, brands, and future requirements.
Teams should begin with simple, reusable foundations, connect design decisions to code where practical, and continually revise the system based on actual usage rather than treating it as a finished artifact.
Figma’s collaboration features help Lambda School recreate the engagement and hands-on interaction of an in-person design classroom online. Students learn through shared presentations, live design work, peer feedback, and visible iteration rather than passively watching lectures. Because their work remains organized in Figma, the same files also support portfolio creation and continued peer learning.
## Interactive, Collaborative Lessons
- Lambda School is a nine-month, live online program offering training in web development, mobile development, data science, and UX design.
- Instructors present lessons in Figma during video conferences, allowing students to:
- Zoom into designs and examine details.
- Scroll through examples independently.
- Use visible cursors to follow specific points in a presentation.
- Students create and refine designs directly in shared Figma files.
- Everyone can observe work in progress, learn from classmates, provide feedback, and remix existing designs.
- This mirrors the collaborative workflows students will encounter on professional design teams.
## Real-Time and Asynchronous Feedback
- Students and instructors can comment, tap each other for input, and work together in the same file.
- Open audio, browser-based editing, and comments let students collaborate without constantly interrupting one another.
- Students can work independently while classmates observe, take notes, or leave comments for later review.
- When needed, an instructor or peer can join in and directly adjust pixels alongside the student.
- Voting tools, such as stars, also encourage students to recognize and respond to one another’s work.
## A Lasting Record for Portfolios
- Figma automatically preserves students’ designs, revisions, and project history.
- This makes it easier to assemble a professional portfolio without searching through scattered files.
- Students can focus more on interviews and career preparation while still presenting their development process.
- Classmates’ work remains accessible after lessons, creating an ongoing resource for inspiration and learning.
- The approach supports Lambda School’s broader career mission, which includes coaching, mentors, and connections to hiring partners.
Figma’s use at Lambda School demonstrates how collaborative design tools can make remote education interactive, social, and career-oriented. Programs teaching practical creative skills can benefit from combining live instruction with shared workspaces that preserve feedback, iteration, and student progress.
Figma highlights five utility plugins designed to eliminate repetitive design tasks and make workflows more efficient. They support responsive frame testing, component duplication, text manipulation, bulk replacement, and selection of similar layers. A keyboard shortcut tip further speeds up plugin access.
## Viewports
- Resizes frames to common device dimensions.
- Requires constraints to be configured on elements beforehand.
- Displays estimated global market share for each device viewport.
- Future versions were expected to include desktop sizes.
## Component Cloner
- Duplicates master components, selected instances, or both.
- Useful for testing variations such as icon colors and building icon sprites.
- Removes the manual work of recreating components and their instances.
## Nisa Text Splitter
- Converts lines in a text box into separate text objects.
- Supports reordering, including alphabetical or reverse order.
- Can also merge multiple text boxes into one.
## Find and Replace
- Finds and replaces text throughout a Figma document.
- Can also search and rename layers by name.
- Supports case sensitivity and matching anywhere, at the beginning, at the end, or across the entire string.
- Particularly useful for large copy or content revisions.
## Similayer
- Selects layers based on chosen matching properties.
- Can match attributes such as fill, stroke, border radius, and drop shadow.
- Extends Figma’s native “Select all with same…” functionality while reducing repetitive clicks.
## Faster Plugin Access
- Press `⌘ + /` on Mac or `Ctrl + /` on Windows to search the menu and launch a plugin by name.
- Press `⌘ + ⌥ + P` on Mac or `Ctrl + Alt + P` on Windows to run the previous plugin.
These plugins are practical additions for reducing repetitive work in Figma. Designers can adopt them immediately, while developers interested in creating similar tools can consult Figma’s Plugin API documentation.
Figma announced the beta of its plugin platform, inviting developers to build tools that extend and improve design workflows. The initiative follows the success of Figma’s HTTP API and aims to make plugins powerful while preserving platform stability, security, performance, and compatibility. Figma initially planned a limited beta, with broader access and community-created plugins to follow.
## Opening the Figma Platform
- Figma had previously launched an HTTP-based API for exporting design data and connecting Figma with other tools.
- Customers used the API to:
- Export icons through custom Slack commands.
- Push design updates into development environments.
- Maintain and distribute GitHub’s Octicons SVG library.
- Independent designers and developers had also begun creating spaces for sharing Figma-related functionality.
## Designing a Stable Plugin System
Figma recognized that plugins can create compatibility, security, and performance challenges. Rather than exposing internal APIs—which may change frequently—it designed dedicated third-party APIs intended to remain stable as Figma evolves.
The company established several principles:
- Plugins should be intuitive for all designers.
- Anyone capable of building a website should be able to create a plugin.
- Developers should be able to use popular programming languages.
- Plugins should not harm Figma’s performance or user experience.
- Figma would fully support and maintain the APIs used by plugins.
## What Plugins Could Do
During the beta, developers could create plugins to:
- Automate repetitive design tasks.
- Speed up design workflows.
- Import real-world data into Figma files.
- Share plugins with teammates.
Because Figma is web-based, the company expected plugins to be relatively easy to build and maintain for developers familiar with HTML and JavaScript.
## Beta Access and Future Availability
- The beta was limited to a selected group of users.
- Applicants were prioritized based on the ideas they wanted to build.
- Figma intended to use the beta to stress-test and refine its plugin APIs.
- Broader access was planned for the future.
- Non-coders would eventually be able to use community-built plugins.
Developers with basic web-development skills and a plugin idea were encouraged to apply for the beta.
UAL’s fragmented history across six colleges created inconsistent digital experiences and made collaboration difficult. Midway through a website redesign, the UX team switched from Sketch to Figma, gaining real-time collaboration and a shared source of truth. That change unexpectedly led to a flexible design system that aligned designers, developers, stakeholders, and external agencies while accelerating delivery.
## A Fragmented Digital Identity
- UAL consists of six colleges, each with its own history, identity, and website practices.
- Individual teams preferred implementing their own styles, resulting in inconsistent digital experiences.
- As part of a 2017 Digital Transformation Program, UAL began redesigning its core website to become more user-centric.
- Although a design system was not initially the main objective, it emerged naturally during the project.
## Switching from Sketch to Figma
- The team struggled with Sketch’s siloed files, versioning problems, syncing delays, and limited collaboration.
- These issues were especially difficult because stakeholders and agencies were distributed across 14 campuses.
- Figma enabled browser-based, real-time collaboration and allowed the team to import Sketch files easily.
- Designers, developers, executives, and other stakeholders could work from one centralized source of truth.
- The shared workspace improved transparency and helped repair the disconnect between design and development.
## Building the Design System
- Since the website had to be built largely from scratch, the team prioritized creating reusable design-system foundations.
- The design system was intended to unify not only the website but also UAL’s broader digital channels.
- Workshops with students and business partners helped identify essential features, components, and inconsistencies.
- The system had to support UAL’s complex brand, including variations in color, typography, and visual personality.
- Figma’s team libraries created a living, accessible version of the brand guidelines.
- Figma Styles allowed color, text, and effect styles to be managed independently, providing additional flexibility.
## Faster Delivery Through Reusable Components
- The team used components to create base pages that served as templates for future pages.
- Developers could build new pages more quickly and see how designs translated into code.
- Designers and developers worked from the same system, reducing communication gaps and improving coordination.
- The design system became both a visual foundation and a practical workflow for speeding up website production.
UAL’s experience shows that a design system can emerge from solving everyday collaboration and consistency problems. Centralized tools, reusable components, shared libraries, and close designer-developer collaboration helped transform an unwieldy redesign into a faster and more unified digital process.
Figma’s Live Embed Kit lets anyone place continuously updated Figma designs and prototypes on websites or inside third-party tools. Embeds use a simple iframe and remain synchronized with the original file, eliminating repeated exports and uploads. Figma presents the kit as a way to improve team communication and signals future platform tools, including a planned API.
## Simple Embedding for Websites and Tools
- Users can select **Share → Public embed** in a Figma file and copy the generated iframe code.
- Developers can integrate Live Embeds into their own products using Figma’s embed documentation.
- Third-party platforms such as Trello, JIRA, and Dropbox Paper can enable Figma embeds for their users.
## Always-Up-to-Date Designs
- Because Figma runs on the web, embedded files stay synchronized with the source document.
- Small changes—such as adjusting padding or replacing an icon—appear automatically in every embed.
- Teams no longer need to re-export designs or upload updated files manually.
## Collaboration Use Cases
- Internal wikis can display live designs alongside project and feature documentation.
- Team messaging apps can let users share the latest design versions in conversations.
- Blogs and project pages can show designs that remain current for readers.
## Broader Platform Direction
- Figma aims to reduce the confusion caused by outdated files scattered across email, Slack, and file-sharing services.
- The Live Embed Kit is described as an early step in expanding Figma’s platform.
- Figma planned to release an API for retrieving additional information from files and incorporating it into new workflows.
The kit is recommended for teams and developers that want design updates to flow automatically into the places where people communicate, document, and build products.
Datadog’s Notebooks feature demonstrates that interns can make substantial contributions when given meaningful ownership and effective mentorship. Marie-Laure Bardonnet progressed from small bug fixes to prototyping the feature, gaining hands-on experience with React, Redux, and Redux Saga. Her experience ultimately led to continued part-time work and a full-time role at Datadog.
## From Bug Fixes to Feature Ownership
- Marie-Laure initially handled small issues, such as fixing a dashboard favorite-star interaction.
- Gradually more complex tasks helped her learn Datadog’s codebase and application architecture.
- Rather than limiting her to routine maintenance, Datadog assigned her a major project earlier than expected.
## Building Datadog Notebooks
- Notebooks let users save graphs from a specific point in time alongside text and other contextual information.
- The feature is designed to preserve and share organizational knowledge, helping teams respond more quickly.
- Marie-Laure built most of the prototype during her seven-month internship.
- The project introduced her to:
- React for the frontend
- Redux for state management
- Redux Saga for handling side effects
## The Role of Mentorship
- Team lead Ivan DiLernia gave Marie-Laure substantial autonomy while remaining available for difficult architectural decisions.
- He encouraged her to investigate ideas independently, then collaborated with her when problems required deeper discussion.
- Marie-Laure identified this balance between independence and guidance as one of the most valuable parts of the internship.
## Lasting Impact
- The internship changed how Marie-Laure viewed her academic coursework, helping her distinguish practical engineering skills from more theoretical material.
- After returning to France, she continued working part-time on Notebooks and other web-platform projects.
- She later completed her studies and accepted a full-time position at Datadog.
Datadog’s experience suggests that internships are most effective when they combine gradual onboarding, meaningful technical ownership, and thoughtful mentorship rather than restricting interns to low-impact tasks.
