Accept Some Dynamic Behavior with unknown
You'll learn when to embrace unknown and runtime checks instead of forcing compile-time type guarantees that don't match reality.
The Limits of Static Types
TypeScript is a compile-time type system layered over JavaScript, a fundamentally dynamic language. Sometimes the best approach isn't to model every possible type scenario perfectly—it's to acknowledge that certain data is truly unpredictable and handle it safely at runtime.
unknown is your ally when types can't realistically capture what's happening. Rather than twisting yourself into increasingly complex type gymnastics or lying to the compiler with type assertions, accept the dynamic nature of the situation.
When to Choose unknown Over Type Precision
Consider these scenarios where unknown is the honest choice:
User-generated content: You cannot predict what users will submit through form fields or file uploads. Type it as unknown and validate at runtime.
Polymorphic plugin systems: When third-party code registers handlers or transforms, you often can't know their shapes in advance. Accept unknown inputs and guard defensively.
Legacy integration boundaries: When calling ancient APIs or interfacing with systems that predate your type definitions, unknown acknowledges reality better than pretending you have guarantees.
Performance-critical paths: Sometimes complex conditional types slow down the compiler significantly. Using unknown with focused runtime checks can be both faster to compile and clearer to maintain.
The Trade-off
You're trading compile-time safety for runtime flexibility and maintainability. The key is containing this dynamism at boundaries—parse once with runtime validation, then work with properly typed data throughout the rest of your codebase.
Key Takeaway: Don't force TypeScript to model what it can't know. Use unknown with runtime checks for truly dynamic scenarios, keeping the complexity at system boundaries rather than spreading it through your entire type system.