PROVIDER - Independent type and design market

YouWorkForThem

YouWorkForThem is a US marketplace for independent fonts and design assets where families are bought outright with the web licence included, and the strength is experimental display work from small foundries rather than catalogue breadth.

Web Fonts United States 2026.11.20
3.7pts

Detailed Notes

Pros 5 items

Families are bought outright in 1 payment and the price already includes a web font licence, with no monthly pageview fees afterwards
Families come from 2 source types, independent foundries and individual designers, with a much higher share of display and experimental work than large retail platforms
Each family page lists 3 attributes covering character coverage, available weights, and licence scope so language coverage can be checked before buying
Beyond fonts the marketplace sells vector graphics, templates, and sound effects, so 1 order can bundle several assets for a brand project
Specimens and custom preview text give 2 preview modes so headlines, body copy, and multilingual samples compare in real context

Cons 4 items

The purchase licence covers web use, but self hosting, app embedding, and redistribution are written per foundry and must be read family by family
Experimental display families dominate, while families suited to body copy are fewer, so long form sites need extra screening and testing
CJK fonts are essentially absent, so multilingual projects can only cover the Latin layer
Support runs on email, and missing files or licence questions move slower than on large platforms with ticketing and documentation

Service Overview

YouWorkForThem is an independent marketplace for fonts and design assets headquartered in the United States, where the sellers are independent foundries and individual designers and the catalogue spans font families plus vector graphics, templates, and sound effects. Within the web fonts category it represents the outright purchase plus strong visual identity tier. The transaction is direct: one family, one payment, and the web font licence is already inside the price, with no pageview renewals afterwards.

That model appeals to projects with a fixed budget. A subscription ties long term cost to traffic and revokes the licence when payments stop, while a purchase puts the licence into the project once, so redesigns, domain moves, and traffic doubling no longer trigger a new cost decision. For brands where the visual style is the product, that clarity matters more than catalogue size.

The differentiation is structural. Display faces, experimental glyph sets, and hand made textures take a much larger share than on large retail platforms, and many pieces come from tiny foundries with one or two families, closer to independent magazines and record sleeves than to corporate identity work. When a headline needs to look like nothing else on the shelf, this catalogue gets there faster than a general library.

The cost is screening and paperwork. Experimental families outnumber body copy families, and foundries write self hosting, app embedding, and redistribution clauses differently, so two items in one cart can carry two different rule sets that both have to be read before checkout.

Key Strengths

  • One time purchase with web rights included: the licence lands once, so traffic growth, domain moves, and redesigns no longer reopen the question, which makes long term cost predictable
  • Distinct visual identity: the high share of display and experimental glyphs makes it hard to collide with the default choices everyone else uses
  • Concentrated independent foundry work: many studios with only one or two families sell here, which surfaces designs that never clear the bar at larger platforms
  • Fonts and design assets in one source: an order can include type, vector graphics, and templates, which keeps a brand project visually consistent
  • Specimens with custom previews: project headlines, multilingual samples, and body sizes can be compared in context before purchase

Product Ecosystem

Platform capabilities

The marketplace organises goods into fonts, graphics, templates, and sound effects. Fonts sell by family, and each family page lists every weight, character coverage, and licence type. The preview tool accepts custom text and sizes, which shows how spacing behaves when a display face is set across a long headline. Delivery is immediate after checkout: the package normally contains desktop install files and web font files, with woff and woff2 formats plus a sample stylesheet.

Integrations

The web portion is standard font files plus a sample CSS, and integration is up to the project: drop the package into a static directory and write @font-face, or reference the sample stylesheet. Three jobs remain with the buyer: subsetting, because many families ship very complete character sets and the full package is heavy; font-display strategy, because complex display glyphs make the fallback swap more visible; and the licensed domain list, since a purchase does not mean unlimited redistribution to any site.

Typical scenarios

Independent magazines and brand identity work is the natural home, since a headline system built from one display family sets the tone immediately. Campaign landing pages and poster style single page sites pick one display family and finish. Streetwear, record labels, and independent shops use it for packaging and packaging adjacent visuals. Product interfaces and long form body copy need a neutral readable family instead, which is not where this catalogue leads.

Limitations

  • Terms differ per family: self hosting, app embedding, redistribution, and trademark use are set by each foundry, so inconsistent rules inside one order are normal and must be read item by item
  • Few body copy families: display work is rich but faces that hold up at small sizes are limited, so long form sites usually use it for headlines and keep body copy on an open source face
  • No CJK coverage: Chinese, Japanese, and Korean families are effectively missing, which limits Chinese first sites to the Latin layer and forces manual weight matching
  • Email only support: missing files, format problems, and licence questions go through email, which moves slower than platforms with ticketing and structured documentation

Use Cases

  • Independent brands and magazines (★★★★★): the display range is wide, so the headline voice differentiates quickly, which is where the catalogue pays off most
  • Campaign pages and poster style sites (★★★★☆): one or two display families carry the whole page, and a purchase leaves no subscription behind when the campaign ends
  • Streetwear, record labels, and independent shops (★★★★): fonts and graphics come from one source, which keeps the visual system consistent
  • Sites with long term body copy needs (★★★): body families are limited, so it usually handles the headline layer while body copy borrows a more readable face
  • Chinese or multilingual first sites (★★): almost no CJK coverage, so only the Latin portion can be served

Pricing

Item Price Notes
Single family purchase Priced per family, usually one to several weights, see the official quote The price includes the web font licence and no pageview charges follow
Font plus asset bundle Summed per item, some listings offer bundle pricing, see the official quote One order can combine fonts, vector graphics, and templates
Extended licence for apps, embedding, redistribution Quoted per use case, subject to the official terms Set by each foundry, so it must be checked family by family

Prices vary with the family, weight count, and foundry, so the official quote is the reference. Comparing the purchase price against two or three years of subscription fees is usually the right framing, because the purchase cost curve is flat; include extended licence fees as well, or an app embedding requirement discovered after launch can force a second purchase.

FAQ

Are there pageview fees after purchase?

No. The family price includes the web font licence and is not billed by monthly pageviews, so traffic growth adds no cost. The licence is still tied to the use declared at purchase, and serving the fonts on other projects or client sites usually falls outside it.

Can the font files be self hosted?

Most families allow self hosting, but each foundry writes it differently, with some explicit and others bounded. Read the licence page before buying and keep a record of the domains in use so later audits have something to check against.

Are there families suited to body copy?

Yes, but fewer than the display selection. Screen on character coverage and weight count first and test at small sizes; if the body sizes disappoint, using the family for headlines and an open source face for body copy is the safer arrangement.

How is this different from a large font retailer?

Large retailers win on catalogue size and consistent terms with a standardised selection path. This marketplace wins on visual distinctiveness and predictable purchase cost, at the price of more complex terms and slower support.

Code Examples

Organise the web font package from an order

# The font package comes from the order download page; keep the path in an environment variable
: "${YWT_FONT_ZIP:?path to the web font archive from the order}"
: "${YWT_OUT_DIR:=assets/fonts}"

mkdir -p "$YWT_OUT_DIR"
unzip -o "$YWT_FONT_ZIP" -d "$YWT_OUT_DIR" >/dev/null

# Keep woff2 as the primary format and move woff into a legacy folder
find "$YWT_OUT_DIR" -name '*.woff2' | sort
echo "woff2 count: $(find "$YWT_OUT_DIR" -name '*.woff2' | wc -l | tr -d ' ')"
echo "license files:"; find "$YWT_OUT_DIR" -iname '*license*' -o -iname '*ofl*' | sort

The package usually ships with a licence note, and keeping it in version control next to the files makes later audits straightforward.

Generate self hosted @font-face rules and report weight

#!/usr/bin/env python3
# Scan a local font folder, emit @font-face rules per family, and report total size
import pathlib
import re

font_dir = pathlib.Path("assets/fonts")
faces = []

for path in sorted(font_dir.rglob("*.woff2")):
    stem = path.stem                      # for example "DisplayFamily-Bold"
    family, _, style = stem.partition("-")
    weight = "700" if re.search(r"bold", style, re.I) else "400"
    faces.append(
        "@font-face {\n"
        f'  font-family: "{family}";\n'
        f'  src: url("/fonts/{path.name}") format("woff2");\n'
        f"  font-weight: {weight};\n"
        "  font-display: swap;\n"
        "}"
    )

css = "\n\n".join(faces)
pathlib.Path("assets/fonts/fonts.css").write_text(css, encoding="utf-8")
total = sum(p.stat().st_size for p in font_dir.rglob("*.woff2"))
print("faces:", len(faces))
print("woff2 total KB:", round(total / 1024, 1))

The naming rule is only a starting point. Family names and weights have to be corrected against the package naming, otherwise the browser treats two weights as one face and drops one of them.

Community & Resources

Visit YouWorkForThem Website → https://www.youworkforthem.com/
Visit Website ↗