TL;DR
Get monitors, keyboards and dev gear delivered free — and shop member deals
- Fast, free delivery on millions of items
- Access to Prime Big Deal Days deals on October 6–7
- Prime Video, Amazon Music and more included
A commentary published October 3 argues that developers’ reluctance to “use the platform” reflects more than missing browser features: ecosystem habits, documentation and the appeal of building custom tools also matter. The author says homemade solutions can teach developers, but warns that unfamiliarity with existing platform features can lead to avoidable reinvention.
Web developer Nolan Lawson argues that developers do not always choose browser features over libraries and custom code because the platform is inadequate: familiar tooling, uneven documentation and the enjoyment of building things themselves can also shape the decision. In an analysis published October 3, Lawson examines the reasons behind resistance to the long-running advice to “use the platform”, while acknowledging that custom implementations can also reflect gaps in developers’ knowledge.
“Use the platform” is advice to rely on features built into browsers, such as CSS and native HTML elements, instead of recreating their functions in JavaScript. Lawson, writing on his Read the Tea Leaves site, says the advice has a sound practical basis: browser features can provide performance and usability benefits that a developer-made substitute may not match. But he says that history helps explain why developers learned to reach for libraries instead. For years, browser support was uneven, and libraries such as jQuery provided capabilities while browser vendors caught up. Compatibility with older browsers could also delay adoption of newer features.
Lawson says familiarity and presentation matter, too. Developers accustomed to finding components on npm may reach for a package even when a browser feature could solve the problem. He notes that libraries can still add value by presenting lower-level browser capabilities through patterns familiar to a framework’s users. In his example, a React component library may use direct DOM operations internally while offering an interface more accessible to developers working in React.
Documentation can influence the choice. Lawson contrasts the detailed guides and examples available for many packages with the historically scattered documentation for browser APIs. He says MDN later became a central reference for web documentation, while Google’s web.dev serves as a more forward-looking resource. He also argues that some developers enjoy building their own solutions, partly because doing so can make unfamiliar systems easier to understand and offers room to experiment.
Why Developers Rebuild Browser Features
The choice between a browser feature and a custom implementation affects more than coding style. Lawson’s analysis points to a practical tension: native features may reduce duplicated work and offer established browser behavior, while a library can make a capability easier to adopt within a particular framework or fill a gap in usability and documentation. Developers deciding what to use need to weigh the available platform support against the costs and benefits of an external dependency or custom code.
There is also a learning effect. Lawson describes building tools as a route to deeper knowledge of browser behavior and standards work. He says his work on storage tools for PouchDB helped him develop expertise in IndexedDB and related standards. That is his personal account, not evidence that custom implementations are always a better way to learn. The broader point is that replacing every custom solution with a native API may overlook the expertise and experimentation that helped developers understand the platform in the first place.
HTML and CSS browser developer tools
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
From Browser Gaps to Native APIs
The phrase “use the platform” emerged from advocacy for web standards, performance and accessibility. Its central argument is that browser vendors already provide features that developers otherwise might reproduce themselves. The advice became harder to follow when browser implementations lagged behind what developers needed, and when older browsers remained in widespread use.
Lawson says that environment has changed as browsers have moved toward more frequent updates, though he describes browser release patterns as not entirely uniform. The ecosystem has also developed conventions of its own: npm packages, framework components, tutorials and examples can make third-party solutions easier to discover than a native API. His analysis revisits these explanations and adds a less technical motivation: the satisfaction some developers get from making and refining their own tools.
““Why build something yourself, in JavaScript, when the browser can do it for you?””
— Nolan Lawson, writing in Read the Tea Leaves
JavaScript library development books
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Where Custom Code Falls Short
Lawson’s article is an analysis of possible motivations, not a survey measuring how often developers choose libraries, native browser features or custom implementations. It does not quantify the relative influence of history, documentation, familiarity or enjoyment, and it does not establish how those factors vary by framework, project or team.
The source material also ends as Lawson begins discussing ignorance as another reason developers may recreate functionality, particularly when they do not know that CSS can solve a problem. The available text does not include the remainder of that discussion. It therefore does not provide a complete account of his conclusions about when custom implementations are poorly informed or how developers should evaluate each case.
web development documentation resources
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Choosing APIs Project by Project
Lawson’s analysis does not announce a new browser feature, policy or deadline. Its practical implication is to check what browsers already support before adding a dependency or writing a replacement, while considering whether a library offers useful documentation or a simpler interface. Developers also need to account for the project’s browser-support requirements and the behavior the feature must provide.
The article leaves the decision case-specific: a native feature may be the better fit, but platform advocacy alone does not settle whether a library or custom implementation is justified. The available source provides no follow-up data or announced next milestone against which the argument could be measured.
As an affiliate, we earn on qualifying purchases.
Key Questions
What does “use the platform” mean?
It means using features provided by browsers, such as native HTML elements and CSS, rather than recreating the same behavior with JavaScript or a third-party package.
Why might developers choose a library instead?
Lawson identifies several possible reasons: past browser compatibility gaps, familiarity with tools such as npm and framework components, and documentation that can be easier to find or follow than platform API guidance. A library may also offer a more familiar interface for a lower-level browser feature.
Does Lawson argue that custom code is always better?
No. He describes the appeal and learning value of building tools, but also says custom work can result from not knowing that an existing platform feature can solve the problem. His analysis does not claim that every custom implementation is preferable.
What example does Lawson give of learning through custom work?
Lawson says his work on PouchDB storage tools, including work related to IndexedDB and WebSQL, helped him build expertise that later informed his participation in standards discussions.
Does the analysis measure how common these motivations are?
No. The article offers Lawson’s explanations and personal experience, but the source material provides no survey or quantitative data about how frequently developers choose custom code, packages or native browser features.
Source: hn
Halloween Picks
halloween
As an affiliate, we earn on qualifying purchases.
