How do you create reusable types?

Creating reusable types is a fundamental skill in software development, especially in strongly typed languages like TypeScript, C#, or Java. It’s not just about writing types once and using them everywhere; it’s about designing types that are flexible, maintainable, and scalable across your codebase. Reusable types help reduce duplication, improve code clarity, and make your APIs or modules easier to understand and extend.

From my experience, reusable types are a combination of thoughtful design, understanding the domain, and anticipating how your data structures will evolve. Let me walk you through the core concepts, practical examples, common pitfalls, and best practices that I’ve learned over the years.

What Does “Reusable Types” Mean?

At its core, reusable types are type definitions that can be applied across multiple parts of your application or even across different projects without rewriting or duplicating them. This can include interfaces, type aliases, enums, generics, or even utility types that abstract common patterns.

For example, if you have a User type that represents user data, making it reusable means defining it once and using it consistently wherever user data is involved—whether in API responses, form inputs, or database models.

Core Concepts for Creating Reusable Types

1. Use Interfaces and Type Aliases Thoughtfully

Interfaces and type aliases are the building blocks of reusable types. Interfaces are great for describing object shapes and are extendable, which makes them ideal for reuse and composition. Type aliases are more flexible—they can represent primitives, unions, tuples, or intersections.

interface User {
  id: string;
  name: string;
  email: string;
}

type ID = string | number;

Interfaces are often preferred when you expect your types to be extended or implemented by classes. Type aliases are handy for unions or complex compositions.

2. Embrace Generics for Flexibility

Generics allow you to write types that work with a variety of data types without sacrificing type safety. This is especially useful for collections, wrappers, or utility types.

interface ApiResponse<T> {
  data: T;
  error?: string;
  status: number;
}

Here, ApiResponse can be reused for any data type, making it extremely versatile for different API endpoints.

3. Composition Over Inheritance

Instead of creating large monolithic types, break them down into smaller reusable pieces and compose them. This approach improves maintainability and reduces duplication.

interface Address {
  street: string;
  city: string;
  zipCode: string;
}

interface User {
  id: string;
  name: string;
  address: Address;
}

By separating Address as its own type, you can reuse it anywhere an address is needed, like in Company or Order types.

4. Use Utility Types and Mapped Types

Languages like TypeScript provide built-in utility types such as Partial, Pick, and Omit that help you create variations of existing types without duplication.

interface User {
  id: string;
  name: string;
  email: string;
  isActive: boolean;
}

// Create a type for updating user info where all fields are optional
type UserUpdate = Partial<User>;

Mapped types let you transform types programmatically, which is powerful for creating reusable patterns.

Real-World Examples of Reusable Types

API Data Models

In many projects, you’ll have API response types that are reused across frontend and backend. Defining these types once and sharing them (via a shared package or monorepo) reduces bugs and keeps your contract consistent.

interface Pagination {
  page: number;
  pageSize: number;
  total: number;
}

interface UserListResponse {
  users: User[];
  pagination: Pagination;
}

This way, the pagination type can be reused for any list response, not just users.

Form Data and Validation

Form input types often mirror your data models but with some tweaks. Using reusable types with utility types helps avoid duplication.

type UserFormInput = Omit<User, 'id'> && { password: string };

This type reuses User but excludes the id (which might be generated server-side) and adds a password field for registration forms.

Best Practices for Reusable Types

• Keep types focused and small: Avoid giant types that try to cover every case. Smaller, composable types are easier to reuse and maintain.
• Use descriptive names: Clear naming helps other developers understand the purpose of a type quickly.
• Document assumptions: Add comments or documentation for complex types, especially generics or mapped types.
• Share types via packages or monorepos: If you work in a multi-repo environment, consider publishing shared types as npm packages or using a monorepo structure to avoid duplication.
• Version your types: When sharing types across services, version them to avoid breaking changes.

Common Mistakes When Creating Reusable Types

• Overgeneralizing: Trying to make a type too generic can lead to confusing or unusable types. Balance flexibility with clarity.
• Duplicating types: Copy-pasting types across files or projects leads to maintenance headaches and bugs.
• Ignoring domain boundaries: Reusing types across unrelated domains can cause tight coupling and confusion.
• Not using utility types: Developers sometimes rewrite variations of types manually instead of using built-in utilities, increasing code size and errors.

Performance Considerations

Types themselves don’t impact runtime performance since they are erased during compilation (in TypeScript, for example). However, well-designed reusable types improve developer productivity and reduce bugs, which indirectly affects the performance of your development lifecycle.

On the flip side, overly complex types can slow down your IDE’s type checking and autocomplete, especially in large codebases. So, keep your types as simple as possible while meeting your needs.

Security Considerations

While types don’t enforce security at runtime, they help prevent common bugs that can lead to vulnerabilities. For instance, strict typing can catch missing fields or incorrect data shapes that might otherwise cause injection flaws or data leaks.

When designing reusable types for APIs, make sure to clearly differentiate between internal and external data shapes. For example, don’t expose sensitive fields like passwords or tokens in your public types.

Interview Tips for Discussing Reusable Types

• Explain your reasoning: Don’t just say you use interfaces or generics—explain why and how they help reuse and maintainability.
• Give examples: Talk about real projects where reusable types helped reduce bugs or speed up development.
• Mention trade-offs: Show awareness of when to keep types simple vs. when to generalize.
• Discuss tooling: Mention how IDEs, linters, or type checkers help enforce type reuse.
• Be ready to write code: Often, interviewers ask you to write reusable types on the spot—practice common patterns like generics, utility types, and composition.

Comparison: Reusable Types vs. Ad-Hoc Types

Aspect	Reusable Types	Ad-Hoc Types
Maintainability	High – Single source of truth, easier updates	Low – Duplication leads to inconsistencies
Flexibility	High – Use generics and composition	Low – Rigid and specific
Development Speed	Faster in the long run	Faster initially but slows down later
Complexity	Can be complex if overused	Simple but often duplicated

Practical Production Scenario

In a recent project, I worked on a microservices-based e-commerce platform. We had multiple services—user management, orders, inventory—each with its own data models. To avoid duplication and mismatches, we created a shared @types package that included reusable types like User, Product, and Order interfaces.

We used generics for API responses and utility types to create partial update types. This approach saved us countless hours debugging mismatched data shapes and allowed frontend and backend teams to move faster with confidence.

One challenge was managing breaking changes. We implemented semantic versioning and strict code reviews for the shared types package to ensure backward compatibility.

Summary

Reusable types are about more than just code reuse—they’re about designing your data models thoughtfully to improve clarity, reduce bugs, and speed up development. Use interfaces and type aliases appropriately, embrace generics and utility types, and prefer composition over inheritance. Avoid overgeneralizing and duplication, and always keep maintainability in mind.

When preparing for interviews, be ready to discuss your approach to reusable types with practical examples and trade-offs. Demonstrate your understanding of how reusable types impact scalability, performance, and collaboration in real projects.