Configuration is a foundational piece of application architecture that doesn’t get much attention until it becomes a problem. And in fact, many problems do happen, like:

• Environment variables live in multiple places
• Secrets are injected in different ways
• Parts of the codebase grab configuration directly

If these issues are unresolved, over time, no one will know where certain values are coming from.

We ran into this challenge while working on TypeScript applications at Basis. Configuration logic was scattered across the codebase, making it difficult to trace how values were resolved and validate them consistently.

To solve this, we built and open-sourced Tydantic Settings: a flexible, type-safe configuration management library for TypeScript applications. It’s inspired by Python’s pydantic-settings and built on top of TypeBox.

The Problem: Configuration Drift and Hidden Complexity

In many TypeScript applications, configuration is scattered.

• Environment variables accessed directly in multiple files
• Secrets pulled from AWS Secrets Manager ad hoc
• Different configuration logic per environment
• No centralized visibility into how settings are resolved

This creates a few real issues like 

• Difficulty tracing where configuration values originate
• Refactoring configuration becomes risky
• Inconsistent type safety 
• No single source of truth

As our engineer Mark Lovretovich, who built the library, put it:

“We had no clear view of where things were getting configured in the application. Variables were being set in different parts of the code. We needed one centralized place to manage it.”

The Solution: A Centralized, Type-Safe Configuration Layer

Tydantic Settings solves these problems by introducing a single, authoritative configuration layer for your TypeScript application. With Tydantic Settings, you can:

• Define a configuration schema once using TypeBox
• Resolve configuration from multiple sources
• Enforce strict type safety
• Centralize environment logic
• Maintain clear priority rules for merging settings

Supported configuration sources include:

• Environment variables
• .env files
• AWS Secrets Manager
• Custom resolvers

The result is a fully validated, strongly typed configuration object that your application consumes safely, without directly accessing process.env.

Built for Cloud-Native and AWS Environments

For organizations building on AWS, configuration management often includes:

• Secrets stored in AWS Secrets Manager
• Environment variables injected into ECS, EKS, or Lambda
• Differences between staging and production environments
• Infrastructure-as-code pipelines

Tydantic Settings integrates cleanly into these workflows, allowing teams to:

• Standardize configuration across environments
• Reduce duplication of configuration logic
• Improve reliability in serverless and containerized deployments
• Simplify multi-environment configuration management

Because it supports both synchronous and asynchronous resolution, Tydantic Settings is a great way to seamlessly manage configuration in modern cloud-native applications.

Inspired by Pydantic, Built for TypeScript

Python developers have long relied on pydantic-settings for structured configuration management. However, there was no equivalent, idiomatic solution built specifically for TypeScript applications.

Tydantic Settings brings that structured, schema-first approach into the TypeScript ecosystem while leveraging TypeBox for validation and strong typing.

This approach combines:

• Runtime validation
• Compile-time type safety
• Flexible configuration source resolution
• Extensibility for enterprise environments

It allows engineering teams to adopt best practices in configuration management without sacrificing developer experience.

Why This Matters for Modern Applications

Today’s applications run across:

1. Development
2. Staging
3. Production
4. CI/CD pipelines
5. Local containers
6. Cloud environments

Managing configuration across these environments often leads to duplication and inconsistency.

With Tydantic Settings:

• You define configuration once
• You control source priority centrally
• You avoid scattering configuration logic
• You gain a single place to reason about environment differences

It creates a clean boundary between infrastructure concerns and application logic.

What This Means for Basis

At Basis, we believe in contributing back to the open-source community. Tydantic Settings is not an internal-only tool, but a fully open-source and available for anyone to use.

By building and sharing this library, we:

• Improve the TypeScript ecosystem
• Bring proven Python concepts to modern Node environments
• Encourage best practices around configuration management
• Reduce technical debt in future projects

And if the community finds it useful, we hope it becomes a standard pattern for structured configuration in TypeScript applications.

Who Should Consider Using It?

Tydantic Settings is useful if:

• Your application accesses process.env in multiple places
• You’re integrating with AWS Secrets Manager
• You manage multiple deployment environments
• You care about type safety and maintainability
• You want clearer boundaries between infrastructure and application logic

If configuration has started to feel “spread out” in your codebase, this library was built to address exactly that.

Try Tydantic Settings Today

You can explore the repository and documentation here: https://github.com/mlovretovich/tydantic-settings

We’re excited to see how the community adopts and expands upon this approach to configuration management in TypeScript applications.