The Unicode trap I had to design around in a LinkedIn formatter

I built a small tool for formatting LinkedIn posts, and the deceptively simple part was also the most important part:

styled text is not formatting. It is Unicode substitution.

That sounds obvious once you say it out loud, but it changes the product decision.

When someone clicks bold in a normal editor, the text usually remains the same text with a style applied around it. When someone uses a LinkedIn-style formatter, the tool often converts normal characters into mathematical Unicode characters that only look bold or italic.

For example, a plain A may become a styled Unicode character that visually resembles a bold A.

That works because LinkedIn accepts Unicode text in posts. It is also why these formatters are useful. You can create text that appears bold, italic, monospace, or decorative, then paste it into a post without needing LinkedIn to support rich text.

But it comes with tradeoffs.

The tempting bad version

The easy version of a formatter is just a character map:

A -> 𝐀
B -> 𝐁
C -> 𝐂

Then you loop through the input string and swap each supported character.

That gets you a working demo quickly. It also creates a product that quietly encourages people to overuse styled text everywhere.

The first version of the product question was:

How many styles can this tool support?

The better question became:

How do we help people use styles without making the final post worse?

That is a different problem.

Unicode styled text is less harmless than it looks

Styled Unicode can be useful in small doses. It can make a heading easier to spot or make a short list easier to scan.

It can also create issues:

• Screen readers may read styled characters poorly or inconsistently.
• Some search and parsing systems may not treat styled characters like normal text.
• Copying styled text into resumes, applications, or ATS-sensitive fields can be a bad idea.
• Over-styled posts can look noisy and less professional.

That meant the formatter needed to avoid pretending this was normal rich-text formatting.

The product copy had to be honest: use styled text sparingly.

The UI choice: make restraint the default

For LinkedIn Formatter, I wanted the tool to stay quick:

1. Paste plain text.
2. Choose a style.
3. Preview the result.
4. Copy it back into LinkedIn.

But the UI also needed to avoid making every decorative option feel equally recommended.

So the strongest product pattern was not a giant wall of fonts. It was a workflow that makes common professional formatting easy:

• bold for short emphasis
• italic for light contrast
• bullets and line breaks for readability
• preview before copy
• no-login usage for quick one-off edits

Decorative styles can exist, but they should not be the main recommendation for a professional post.

The accessibility note is part of the product

One of the best improvements was simply adding caveats directly into the content and product positioning.

Not as a legal footnote. As product guidance.

If a tool changes text into Unicode lookalikes, users should understand when that is fine and when it is risky.

That is especially true for:

• profile names
• resumes
• job applications
• heavily formatted posts
• content where screen reader clarity matters

The formatter is still useful. The honest framing makes it more useful, not less.

What I would build differently next time

If I were starting the tool from scratch again, I would treat the Unicode caveat as a first-class feature from day one.

I would also test each style against three questions:

1. Does this style help a real post become easier to scan?
2. Does it create avoidable accessibility or parsing problems?
3. Is the UI encouraging people to use it in the right amount?

That third question matters more than it first appears.

Small tools shape user behavior. If a formatter makes loud styles feel like the main event, people will use loud styles. If it makes clean structure feel like the main event, people are more likely to create readable posts.

The lesson

The technical implementation was character mapping.

The product work was deciding what not to encourage.

That is the part I underestimated.

A LinkedIn formatter is not just a Unicode conversion tool. It is also a tiny writing interface, and tiny writing interfaces still need product judgment.