Hey everyone!

It's been just over two weeks since our last release, and we are back with another batch of exciting features and improvements. Here's what's in store for you in Atlas v0.34.

• Ad-hoc Approval Policies for Terraform and GitHub Actions - You can now control when Atlas will require explicit approval during declarative migrations with ad-hoc approval policies.
• Terraform Doc Portal – There is now a portal in our docs dedicated to helping you get started integrating Atlas with your Terraform setup.

Prepared for and presented at GopherCon Israel 2025.

Introduction​

In this post, we will explore different strategies for building scalable multi-tenant applications in Go based on our experience building the backend for Atlas Cloud, which is part of our commercial offering.

But first, let's clarify what we mean by multi-tenant applications.

Multi-tenancy is a property of a system where a single instance serves multiple customers (tenants).

As a commercial enterprise, your goal is, of course, to have lots of customers! But while you want to serve many customers, they expect a smooth and seamless experience, as if they were the only ones using your service.

Two important promises you implicitly make to your customers are:

1. Data Isolation: Each tenant's data is isolated and secure, ensuring that one tenant cannot access another's data.
2. Performance: The application should perform well regardless of the number of tenants, ensuring that one tenant's usage does not degrade the experience for others.

Let's explore some ways in which we might fulfill these promises.

Hey everyone!

It's been a couple of months since our last release, but for good reason. Today, I am super excited to tell you about everything we have been up to. Here's what's in store for you in this release, v0.33:

• Atlas Copilot: A new coding assistant that helps you better manage your Atlas projects by leveraging an agentic, LLM-based approach.
• Support for --include: Atlas Pro users may now use the --include flag to specify which database objects to query during inspection.
• migrate/diff in GitHub Actions, GitLab CI, and CircleCI - Atlas now supports the migrate diff command in GitHub Actions, GitLab CI, and CircleCI. This allows teams to build CI/CD pipelines that automatically generate migration files based on the current state of the database and the desired state of the schema.
• Check-level Lint Policies: Atlas comes pre-packaged with many built in analyzers that can be used to verify the safety of changes to your database. Using Check-level Lint Policies, you can now configure your CI/CD's pipelines sensitivity to these analyzers.
• Support for sensitive annotations in migration files: Migration files can sometimes include sensitive or PII values, either passed in as input variables (using template-directories) or embedded directly in SQL statements. To prevent these values from being logged, Atlas provides a directive for marking files or specific statements as sensitive. This directive can be set at either the file or statement level.
• Atlas Dashboard UI Revamp: We recently revamped the Atlas dashboard UI. The new design is cleaner and more modern, making it easier to navigate and find the information you need. Congrats to the team for their hard work on this!
• Beta / Feedback Programs: We are launching beta/feedback programs for (signup link below):
  • Oracle
  • Google Spanner
  • Snowflake
  • Performance Optimization

Software teams commonly embrace DevOps for delivery, creating automated CI/CD pipelines that allow for rapid and reliable software delivery. Suprisingly, some of these same teams still manage their database schema manually, causing an interesting contrast.

Picture this: a team spent countless hours ensuring that every change to their application code is:

• Version controlled
• Automatically tested, built, and stored in an Artifact Repository
• Automatically deployed
• Easily rolled back

Yet when it comes to making changes to their database schema, the process looks very different: a developer writes a SQL migration script, connects to the production database with privileged access, runs the script manually, and (if successful) continues with deployment. The entire process is in the hands of the developer.

Projects frequently begin with manual database schema management because it's the easiest option, particularly when databases are small, changes are infrequent, and there are no users. However, as applications evolve and schema migrations grow more complex, this practice becomes a looming risk.

Let's explore the pitfalls of manual migrations, the benefits of automated migrations, and getting started with Atlas to automate your database schema management.

Database migrations are fundamental to modern software development, allowing teams to evolve their database schema in a controlled and versioned manner. As applications grow and requirements change, the ability to reliably alter your database is crucial for maintaining data integrity and application stability.

Atlas was originally created to support Ent, a popular Go ORM. From the start, Ent shipped with a simple "auto-migration" feature that could set up the database schema based on the Ent schema. However, as the project grew popular, it became clear that a more robust versioned migration system was needed.

Ent's authors had hoped to add functionality based on the existing "auto-migration" engine to generate migration files, and use an off-the-shelf migration tool to apply them. The most promising candidate was golang-migrate, a widely adopted migration tool in the Go community renowned for its simplicity and wide database support. But like many tools that start simple and grow popular, we realized that golang-migrate, too, has its limitations, and they led us to expand on its abilities.

In this article, we’ll explore some common challenges teams face with traditional migration tools like golang-migrate, and how Atlas takes a different approach to improve the developer experience.

Prepared for SREDay London 2025

Introduction​

Platform engineering is rapidly emerging as a discipline aimed at reducing cognitive load for developers, enabling self-service infrastructure, and establishing best practices for building and operating software at scale. While much of the conversation focuses on CI/CD, Kubernetes, and internal developer platforms, one crucial aspect often remains overlooked: database schema management.

Despite being at the heart of nearly every application, schema changes are still a major source of friction, outages, and bottlenecks. In this post, we'll explore why database schema management deserves a dedicated chapter in the platform engineering playbook and how organizations can integrate it into their platform strategies.

The prompt that nuked the database​

Let me tell you a not-so-fictional story about a developer named Alice. Alice is a backend engineer at a fast-growing startup. One day, her manager asked her to make a small change to the database. The data engineering team was complaining that they were seeing duplicate emails in the user table, and they suspected that the email column did not have a unique constraint.

Hey everyone!

It's been a few weeks since our last release, and we're excited to share today everything that's new in Atlas v0.32. This release is packed with new features, improvements and bug fixes that will make your experience with Atlas even better.

Here are the highlights of this release:

• Ask AI - Since its modest beginning, Atlas has come a long way. What started as a simple CLI tool for declarative schema management is now a full-blown platform. We know that the learning curve for new users can be steep, which is why we are introducing new AI-powered features to help you get started with Atlas.
• SQL Importing - As projects grow, teams often want to split their schema definition across multiple files. Because SQL definitions are imperative and rely on the order of statements, splitting them can be challenging. With the new importing feature its easy to break large SQL schema definitions into smaller parts while keeping them correct and ordered.
• Improved Ent Loader - Users of the popular Ent ORM can use the ent:// URL scheme to load their schema into Atlas. We have added support for multi-schema migrations, composite schemas, and Ent's globalid feature.
• SQL Server Improvements - We have made several improvements to the SQL Server support in Atlas, including support for Full Text Search Index and Temporal Tables.
• PostgreSQL Improvements - We have added support for defining Foreign Servers and Unlogged Tables in PostgreSQL.

Automatic ER Diagrams and Docs for ClickHouse​

When working with a relational database like ClickHouse, understanding the database schema becomes essential for many functions in the organization. Who cares about the schema? Almost everyone who interacts with your data:

• Software engineers and architects use knowledge about the schema to make design decisions when building software.
• Data engineers need to have an accurate understanding of schemas to build correct and efficient data pipelines.
• Data analysts rely on familiarity with the schema to write accurate queries and derive meaningful insights.
• DevOps, SREs, and Production Engineers use schema information (especially recent changes to it) to triage database-related production issues.

Having clear, centralized documentation of your database's schema and its changes can be a valuable asset to foster efficient work and collaboration. Knowing this, many teams have developed some form of strategy to provide this kind of documentation:

• Diagramming tools. Teams use generic diagramming tools like Miro or Draw.io to maintain ER (Entity-Relation) Diagrams representing their database schema. While this is easy to set up, it requires manually updating the documents whenever something changes, often causing documents to go stale and become obsolete.
• Data modeling tools. Alternatively, teams use database modeling software like DataGrip or DBeaver. While these tools automatically inspect your database, understand its schema, and provide interactive diagrams, they have two main downsides: 1) Since they run locally, they require a direct connection and credentials introducing a potential security risk; 2) They do not enable any collaboration, discussion, or sharing of information.
• Enterprise Data Catalogs like Atlan or Alation, provide extensive schema documentation and monitoring; however, they can be quite pricey and difficult to set up.

Enter: Atlas Schema Monitoring​

Atlas offers an automated, secure, and cost-effective solution for monitoring and documenting your ClickHouse schema.

With Atlas, you can:

• Generate ER Diagrams: Visualize your database schema with up-to-date, easy-to-read diagrams.
• Create Searchable Code Docs: Enable your team to quickly find schema details and usage examples.
• Track Schema Changes: Keep a detailed changelog to understand what's changed and why.
• Receive Alerts: Get notified about unexpected or breaking changes to your schema.

All without granting everyone on your team direct access to your production database.

Python has been a top programming language for the past decade, known for its simplicity and rich ecosystem. Many companies use it to build web apps and server software, thanks to frameworks like Django and SQLAlchemy.

One of the most common (and often loathed) tasks when building backend applications is managing the database schema. As the app's data model evolves, developers need to modify the database schema to reflect those changes. This is where database schema migration tools come into play.

Hey everyone!

Welcome to the second Atlas release of 2025, v0.31! We're excited to share the latest updates and improvements with you. In this release you will find:

• Custom schema rules: You can now define custom rules for your database schema and have Atlas enforce them for you during CI.

• pgvector support: We've added support for managing schemas for projects that use the LLM-based pgvector extension.

• Drift detection: It is now simpler to set up drift detection checks to alert you when a target database isn't in the state it's supposed to be in.

• Multi-project ER Diagrams: you can now create composite ER diagrams that stitch schema objects from multiple Atlas projects.