frontenddogma.com

Frontend Dogma is a daily-updated link digest for web developers and designers, covering material "from the 1990s to now." Each entry pairs a headline with a date, a sequential entry number, source markers in parentheses, and topic tags. Links are preserved through the Wayback Machine, so you can still reach the original article after a site changes or disappears. If you want a traceable, archive-backed feed of frontend news rather than a single publication's own reporting, this structure is the main reason to follow it.

What a single entry contains

Every item follows the same compact format. From the site's own listing:

• Headline — e.g., "Shipping Is the Foundation"
• Source marker — a short code in parentheses, e.g., ( sea ), ( str ), ( fro ), ( sta ), ( the ), ( ele / des ), ( web ), ( eva ), ( sac / dev ), ( sem ), ( cor )
• Date — e.g., Oct 3, 2026
• Entry number — a running count, e.g., 23563
• Topic tags — comma-separated, e.g., fundamentals, career

The source marker tells you where the item came from; the tags tell you what it is about. Together they let you scan by origin or by subject without opening anything.

How sourcing works

The source markers are abbreviations rather than full publication names, so the marker itself is a pointer to the outlet that produced the piece. Examples visible in the listing include ( sea ), ( str ), ( fro ), ( sta ), ( the ), ( ele / des ), ( web ), ( eva ), ( sac / dev ), ( sem ), and ( cor ). Some entries carry a compound marker such as ( ele / des ), indicating more than one contributing source.

Two sourcing behaviors are worth noting if reliability is your concern:

1. Archival preservation. Frontend Dogma states that it preserves links using the Wayback Machine, and it points readers to donate to the Internet Archive to support that work. This means the digest is not just a link list — it is a link list with a fallback copy of the destination.
2. Attribution is explicit per item. Because each headline carries its source marker, you can always see whether you are reading a first-party post, a third-party report, or a video/interview, rather than a rewritten summary.

What the digest does not do, based on the listing, is present itself as original reporting. It aggregates and labels. Treat the reliability question as two separate ones: whether the original source is trustworthy, and whether Frontend Dogma has preserved and correctly attributed it. The second is handled by the marker-plus-archive system; the first is on you to judge at the destination.

How topics are organized

Items are tagged with lowercase topic labels. Tags observed in the listing include:

Tags are applied per item and can stack — for example, one entry carries wordpress, accessibility, legal, wcag, and another carries history, standards, xml, sgml, html, xhtml, hdml, responsive-design, graceful-degradation, mobile, accessibility, user-experience. The stacking is what makes the archive useful for a specific question: you can look for the intersection of, say, accessibility and legal rather than either alone.

The daily update and numbering system

The listing is updated daily, and entries are numbered sequentially — 23563, 23562, 23561, and so on down the page. The number is effectively a stable identifier: if you cite "entry 23557," that reference does not drift even as new items are added above it. Dates run alongside the numbers, so you can also locate an item by the day it was posted.

This matters for two practical reasons:

• You can verify freshness. A high, steadily increasing number plus a current date is direct evidence the feed is active.
• You can cite precisely. Instead of linking a headline that may be reworded, you can reference the entry number.

How to follow it

The site offers several channels, each with a different trade-off:

• RSS feeds — the site says you can stay up to date "on all topics by various RSS feeds." It distinguishes a main feed with exclusive news at $1/month from the other feeds. Note the pricing signal: the exclusive-news feed is a paid tier at that stated rate; the other feeds are described separately and no price is given for them.
• Mastodon — a social feed for following posts.
• Bluesky — a second social feed.

If you want the archive-backed link digest without paying, the non-exclusive feeds and social accounts are the paths described. If you specifically want the exclusive news items, the site states the $1/month main feed as the route.

Deciding whether to follow it long-term

Use these conditions to judge fit:

• Follow it if you want a labeled, dated, archive-preserved stream across a wide tag vocabulary — including history and standards material going back to the 1990s — and you are comfortable treating it as a pointer service whose original sources you evaluate yourself.
• Be cautious if you need original analysis rather than aggregation, or if you want every item to come from a named full publication rather than an abbreviation you have to decode.
• Check the archive behavior yourself if link rot is your main worry: pick an older entry, follow its link, and confirm the Wayback Machine copy resolves. That is the single most testable claim the site makes about its own reliability.

One caveat on scope: the listing mixes technical posts with legal, political, and business items (for example, coverage of ad-tech litigation and AI policy clashes). If you want purely technical signal, the tag system is what lets you filter — but the digest itself does not separate these into distinct feeds based on the evidence here.

An open-source UI element library is a collection of individual, ready-made interface pieces—buttons, cards, inputs, toggles, loaders—that you copy into your own project and adapt. A UI framework, by contrast, is a structured system of components, conventions, and often a theming layer that governs how your whole interface is built. The practical difference: an element library gives you a snippet; a framework gives you a way of working. If you need a polished button in ten minutes, reach for the element library. If you're building a 40-screen product with a team, you probably want the framework.

What "open-source UI element library" actually means

The term gets used loosely, so it helps to separate the parts:

• Open-source: the code is publicly available, and the license tells you what you may do with it—copy, modify, redistribute, or use commercially.
• UI element: a single, self-contained piece of interface, usually small enough to read in one sitting. A button with hover states, a pricing card, a search field.
• Library: a browsable, searchable collection of those elements, typically contributed by many different people.

On a site like Uiverse, elements are shared by a community and written in plain CSS or Tailwind. You find one you like, copy the markup and styles, paste them into your project, and adjust colors, spacing, and text to fit. There's no package to install and no build step required—which is exactly the appeal, and also the source of most of the confusion.

Element library vs. UI framework: the core differences

The table isn't a verdict. It's a map of trade-offs. Element libraries win on speed and freedom; frameworks win on consistency and maintenance.

Licensing and attribution: what to check before you paste

This is where people get into trouble, and it's worth slowing down for.

1. Find the license. Every element or collection should state one. Common open-source licenses include MIT, Apache-2.0, and BSD. Some projects use copyleft licenses like GPL, which can impose obligations if you redistribute your code.
2. Understand what the license permits. MIT and Apache-2.0 are permissive: you can typically use the code in commercial and closed-source projects. Copyleft licenses may require you to release derivative source under the same terms.
3. Check attribution requirements. Permissive licenses usually require you to keep the copyright notice and license text somewhere in your project. That's a real obligation, not a formality.
4. Look for per-element terms. On community sites, the site's overall terms and the individual contributor's stated wishes may differ. If a contributor asks for credit, honor it.
5. When in doubt, ask or avoid. If a snippet has no license at all, you don't have clear permission to reuse it. Treat "no license" as "not open source," even if the code is publicly visible.

This article is general information, not legal advice. For commercial products with real exposure, have someone qualified review the licenses you're relying on.

How to use a community element in your project: a practical workflow

Here's a repeatable process that avoids most of the usual mess.

1. Start from a real need, not a browsing session

Decide what you need first—"a compact primary button with a loading state"—then search. Browsing aimlessly produces a pile of pretty snippets that don't fit together.

2. Copy the smallest version that works

Take the markup and the styles. Strip anything you don't need: demo wrappers, extra animations, decorative layers. Less code means fewer surprises.

3. Convert it to your conventions

If your project uses design tokens or CSS variables, replace hard-coded values:

/* Before: hard-coded */
.button { background: #4f46e5; border-radius: 8px; }

/* After: token-based */
.button { background: var(--color-primary); border-radius: var(--radius-md); }

This one step is what keeps a copied element from looking like a foreign object in your UI.

4. Check accessibility before you ship

Community elements vary widely here. Verify at minimum:

• Keyboard focus is visible and the element is reachable by Tab.
• Color contrast meets WCAG AA (4.5:1 for normal text).
• Interactive elements use semantic HTML (<button>, not a clickable <div>).
• Form inputs have associated labels.
• Motion respects prefers-reduced-motion.

5. Test in context

Paste it into a real page with real content. Long labels, small screens, and dark mode break more copied elements than anything else.

6. Note where it came from

Keep a short comment or an internal credits file: source, license, date. Future you—and your legal reviewer—will be grateful.

Where element libraries genuinely shine

• Prototypes and demos: you need something clickable today, not a design system.
• Landing pages and marketing sites: a handful of distinctive elements, each custom.
• Filling gaps: your framework lacks one specific component, and you don't want to build it from scratch.
• Learning: reading well-made CSS is one of the fastest ways to improve.
• Small projects: a personal site doesn't need a theming architecture.

Where they fall short

• Consistency at scale: ten elements from ten contributors rarely look like one product.
• Maintenance: you own every copy. When your design changes, you edit each one.
• Accessibility debt: you inherit whatever the contributor did or didn't do.
• No upstream fixes: a bug fixed in the original won't reach your copy.
• Integration friction: different naming conventions, different units, different assumptions about resets.

When to choose which

Choose an element library when the scope is small, the timeline is short, or you need a few distinctive pieces rather than a whole system.

Choose a framework or design system when multiple people build multiple screens over months, when consistency is a product requirement, or when accessibility and theming need to be guaranteed rather than checked.

A hybrid works well for many teams: adopt a framework for the structural components—forms, navigation, layout—and borrow individual elements for the places where you want personality. Just route every borrowed element through the same token and accessibility checks, so it lands as part of your system rather than beside it.

The short version: open-source UI element libraries are a fast, flexible way to get good-looking interface pieces into a project. They are not a substitute for a design system, and the license and accessibility details are the part worth reading carefully.

Cybersecurity is the practice of keeping your data, accounts, and services from being accessed, stolen, altered, or knocked offline by someone who shouldn't have them. For a personal site or small online presence, that reduces to a short list of concrete jobs: protect your login credentials, keep your software current, serve traffic over HTTPS, and lock down the domain and DNS layer that everything else depends on. You don't need an enterprise security team to cover the basics — but you do need to treat your registrar account and your hosting account as the two most valuable things you own, because whoever controls those controls the site.

What cybersecurity actually protects

It helps to separate the assets from the threats, because most small-site incidents come from a handful of causes.

The pattern: each asset has one or two controls that remove most of the risk. You don't need all of them on day one, but skipping the account and domain layers is the mistake that's hardest to undo.

The threat categories a small site actually faces

• Credential theft — reused or weak passwords, or credentials leaked from another breached service. This is the most common way small sites fall.
• Phishing — fake login pages or "your domain is expiring" emails designed to capture your registrar or hosting password.
• Malware and backdoors — usually arriving through an outdated CMS, plugin, or theme.
• DDoS — flooding a site until it's unreachable; often handled by your host or a CDN rather than by you.
• Misconfiguration — an open admin panel, directory listing, or default credentials left in place.

Notice that four of the five are about access, not exotic exploits. That's why the basics work.

Core protections to apply first

Use strong, unique passwords and a password manager

Every account tied to your site — registrar, host, CMS, email — should have a different password. A password manager makes this practical. The goal is that one leaked password can't be replayed anywhere else.

Turn on multi-factor authentication

MFA is the single highest-value control for your registrar and hosting accounts. Even if a password is stolen, an attacker without the second factor can't log in. Prefer an authenticator app or hardware key over SMS where the service supports it.

Serve everything over HTTPS

An HTTPS/TLS certificate encrypts traffic between visitors and your site and prevents browser "not secure" warnings. Most hosts and registrars offer a free certificate; the important part is that it's installed and that HTTP redirects to HTTPS.

Update promptly and keep the surface small

Apply CMS, plugin, and theme updates as they're released, and delete anything you're not using. Fewer components means fewer places for a known vulnerability to sit unpatched.

Apply least privilege

Give each person (and each integration) only the access they need. Don't run your site day-to-day from an administrator account, and don't hand out admin rights for tasks that don't require them.

Secure the domain and DNS layer

This layer is easy to overlook and expensive to lose, because a hijacked domain can point anywhere.

• Protect the registrar account with a unique password and MFA. Your registrar account is the root of control over the domain.
• Enable the registrar lock (often called a transfer lock or clientTransferProhibited) so the domain can't be moved without your action.
• Keep registrant contact email secure — that inbox is often the recovery path for the domain.
• Enable DNSSEC where your registrar and DNS provider support it, so responses can be cryptographically validated and spoofing is harder.
• Watch for unauthorized DNS changes — if records you didn't touch appear, treat it as a compromise.

Porkbun is an ICANN-accredited domain registrar, which means it operates under ICANN's registrar rules — relevant here because those rules govern transfers, locks, and registrant contact requirements. Its site lists Stripe among its payment platforms. Beyond that, check your specific registrar's and DNS provider's current feature set for lock and DNSSEC support, since availability varies.

Warning signs and first steps if something looks wrong

Watch for: unexpected DNS records, visitors reporting malware warnings, unexplained admin accounts, a sudden traffic drop, or emails about transfers you didn't request.

If you suspect a compromise:

1. Change passwords on registrar, hosting, and CMS accounts, starting with the registrar.
2. Revoke active sessions and reset MFA where possible.
3. Check DNS records against what you expect and revert unauthorized changes.
4. Restore from a known-good backup if files were altered.
5. Re-scan and update the software before reopening the site.

Containment first, then recovery — don't try to clean a live, still-compromised site.

What to outsource vs. manage yourself

Hosting-level security, CDN, and WAF are usually worth outsourcing because they require scale and constant attention. Account hygiene, MFA, updates, and domain/DNS protection are things you should keep in your own hands regardless of size — they're cheap to do and costly to skip.

Frontend Dogma covers web development and design across a deliberately wide range: fundamentals and career, accessibility and WordPress, browsers, AI and tooling, open-source projects, plus history and standards. Its tagline — "News and Tools for Web Developers, 1990s to Now" — signals that it treats the field as a continuum, not just the current release cycle. If you work on the front end, you will likely find your area represented, but the mix leans toward news, links, and commentary rather than step-by-step tutorials.

The main topic areas

Based on the entries visible on the site, coverage clusters into these groups:

How the topics are organized

Each entry carries a date, an entry number, and a set of topic tags. The tags are the practical way to judge fit: a single item can span several areas at once, as the 90s history piece does by tagging standards, mobile, accessibility, and user experience together. The site also groups content by type — articles, videos, and books on one side; people, projects, and processes on the other; tools and tips and tricks on a third.

What this means for you

• If you care about accessibility, WordPress, or browser quirks, the site covers these directly, including the legal consequences of accessibility failures.
• If you follow AI's effect on development work, there is regular coverage of tooling, productivity claims, and vendor moves.
• If you want historical context for why today's standards and responsive practices look the way they do, that is an explicit part of the editorial scope.
• If you need hands-on tutorials, treat the site as a pointer: entries often link out to the original article, video, or book rather than reproducing the instructions.

One practical note: Frontend Dogma preserves its links using the Wayback Machine and asks readers to donate to the Internet Archive to support that work. That matters if you are relying on older entries — the linked sources are meant to remain reachable.

Frontend Dogma archives the links it publishes through the Wayback Machine so that the articles, videos, and tools it points to remain reachable even after the original pages change, move, or disappear. The site states this practice directly and pairs it with a request to donate to the Internet Archive, the nonprofit that runs the Wayback Machine. If you rely on Frontend Dogma as a long-term reference for web development news, this is the reason its older entries stay usable instead of rotting into dead links.

What the site actually says

From the Frontend Dogma homepage:

• "Frontend Dogma preserves links using the Wayback Machine."
• "Donate to the Internet Archive to support their important work."

That is the full extent of the site's own explanation. It does not publish a longer rationale, a technical description of how snapshots are triggered, or a list of which links get archived. Treat those details as unstated rather than assumed.

Why this matters for a link-heavy news site

Frontend Dogma is a running feed of articles, videos, books, people, projects, processes, tools, and tips from web development and design, updated daily and going back in its coverage to the 1990s. A site with that shape has a structural problem: the value of an old entry depends on the link still working.

Link rot is the normal outcome. Domains lapse, blogs get restructured, companies delete engineering posts, and video hosts remove uploads. When that happens, a curated link becomes a headline with nothing behind it. Archiving the target at the time of publication converts the entry from a pointer into a record.

This is especially relevant for the historical material Frontend Dogma carries. An entry like "Tales from the 90s: On XML's Great Future, the Mobile Web on a 4×20-Character Screen, and Accessibility as the Original Responsive Design" is only useful if the original 1990s-era source can still be read. A Wayback snapshot is often the only remaining copy.

How the two organizations relate

Frontend Dogma does not run its own archive. It depends on the Internet Archive's infrastructure, which is why the donation request appears alongside the preservation statement rather than as a separate appeal.

What you can do

If you want to support the preservation practice: Donate to the Internet Archive, as Frontend Dogma asks. That is the direct lever the site names.

If you want to check whether a link was preserved: Look up the original URL in the Wayback Machine and see whether a snapshot exists near the publication date shown in the Frontend Dogma entry. The site lists dates with each item, which gives you a target window.

If you want to archive something yourself: The Wayback Machine's "Save Page Now" feature lets you create a snapshot of any URL. This is useful for sources you cite in your own writing, since you control the timing rather than hoping someone else archived it.

If you want to keep up with Frontend Dogma: The site offers RSS feeds, including a main feed it describes as carrying exclusive news for $1/month, plus presence on Mastodon and Bluesky. Note that the $1/month figure applies to that specific feed as described on the page; other feeds and channels are listed separately without a stated price.

The practical takeaway

The archiving is a maintenance decision, not a feature you interact with. It means that when you follow an older Frontend Dogma link and the original is gone, there is a reasonable chance a snapshot exists. The donation request is the site's way of acknowledging that this only continues if the Internet Archive continues.