On this page
For most of SageMaker’s life, an ML team on AWS worked across several consoles. Data engineers prepared data in EMR or Glue, analysts queried it in Athena or Redshift, and data scientists trained and deployed models in SageMaker Studio, each with its own identity setup and its own copy of the permissions. Amazon SageMaker Unified Studio is AWS’s answer to that split: one web environment, organised around projects, that sits on top of the services teams already run.
AWS previewed Unified Studio at re:Invent on 3 December 2024 and made it generally available on 13 March 2025, as part of what it calls the next generation of Amazon SageMaker. With the preview, AWS renamed the original machine learning service Amazon SageMaker AI. A year after general availability, two questions matter for MLOps teams: what Unified Studio actually changes in how identity and data access work, and whether an existing SageMaker AI domain should move.
This article covers the domain and project model, what the tools inside a project are, the upgrade path for existing SageMaker Studio domains that AWS shipped in June 2025, the IAM-based domains and serverless notebooks added in November 2025, and a tested script that reports whether a domain is ready to upgrade.
Domains and projects
Unified Studio is built on Amazon DataZone. A domain is the top-level container: it holds users, the SageMaker Catalog and the projects. An existing DataZone domain can be upgraded into a SageMaker unified domain, which needs a domain execution role and a domain service role, and changes the domain’s domainVersion from V1 to V2.
A project is where work happens. Every project is created from a project profile, which is a list of blueprints. The Tooling blueprint is always deployed first: it creates the project’s IAM user role, its security groups and a SageMaker AI domain for the project, along with resources such as an Athena workgroup and Lake Formation permissions. Each project has one project role ARN and one Amazon S3 location, shown on the project details page.

The consequence for security reviews is concrete. Data access is granted to the project role, not to individual tools. When a project subscribes to a dataset in the SageMaker Catalog and the request is approved, the grant goes to the project role, typically through Lake Formation for Glue Data Catalog tables. A notebook, a SQL query and a Spark job in the same project all see the same data, and an audit asks one question: what can this project role read?
Identity Center-based domains sign users in through AWS IAM Identity Center and carry the full governance feature set. IAM-based domains, added in November 2025, authenticate through federated IAM roles, and all users in a project share the same role permissions. Choose Identity Center where per-user identity in audit trails is a requirement; IAM-based domains trade that for faster setup with the roles you already have.
Tools in a project
Unified Studio does not replace the underlying services. It brings together capabilities from Amazon EMR, AWS Glue, Amazon Athena, Amazon Redshift, Amazon Bedrock and SageMaker AI, and each one still runs and bills as itself. What a project offers depends on its profile:
| Capability | Service underneath | Notes |
|---|---|---|
| JupyterLab and Code Editor spaces | SageMaker AI | The same space types as SageMaker Studio, inside the project’s SageMaker AI domain |
| Serverless notebooks with Data Agent | Athena for Apache Spark for Spark cells | Added 21 November 2025; Python, SQL and Spark in one notebook |
| Query editor | Athena, Redshift | SQL over Lakehouse tables |
| Visual ETL and workflows | AWS Glue, Amazon MWAA | MWAA Serverless for IAM-based domains from November 2025 |
| Generative AI apps | Amazon Bedrock | Knowledge Bases, Guardrails, Agents and Flows |
| Model training and deployment | SageMaker AI | Training jobs, pipelines, model registry, endpoints |
| Coding assistance | Amazon Q Developer | Free tier on by default; Pro tier subscriptions add features |
SageMaker Canvas, RStudio on SageMaker AI and AWS Glue DataBrew are not among the tools AWS lists for Unified Studio. If a domain has users of any of them, confirm how those users will reach the tool before you switch off SageMaker Studio access.
Upgrade path for existing SageMaker AI domains
Since 6 June 2025, SageMaker has offered an upgrade from SageMaker Studio to Unified Studio that imports an existing SageMaker AI domain, its user profiles and its spaces without redeploying infrastructure. JupyterLab and Code Editor spaces, training jobs, pipelines, models and inference endpoints created from Studio remain accessible, and users can work in both interfaces during the transition. Administrators decide when to disable Studio access.
At the API level, the link is a UnifiedStudioSettings structure on the SageMaker AI domain. An UpdateDomain call sets it under DomainSettingsForUpdate, with the Unified Studio domain id, project id, environment id, Region, account and project S3 path, and a StudioWebPortalAccess value of ENABLED (both interfaces) or DISABLED (Unified Studio only).
The upgrade starts from SageMaker Studio, not Studio Classic. A domain whose users still open Studio Classic, with JupyterServer and KernelGateway apps, needs the Classic-to-Studio migration first: update the execution role so users can create the new application types, update the VPC configuration if the domain is VPC-only, then switch the default experience. AWS stopped providing fixes for critical issues in Studio Classic notebooks on JupyterLab 3 after 31 December 2024, so that migration is overdue in any case.
%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#FFF3E0', 'primaryTextColor': '#232F3E', 'primaryBorderColor': '#FF9900', 'lineColor': '#232F3E', 'edgeLabelBackground': '#FFFFFF', 'nodeTextColor': '#232F3E'}}}%%
flowchart TD
A["Run readiness report on the SageMaker AI domain"] --> B{"Studio Classic apps or landing URI?"}
B -->|Yes| C["Migrate Studio Classic to Studio"]
C --> A
B -->|No| D["Create the Unified Studio domain and project"]
D --> E["Test custom images, lifecycle configs and VPC access in a project space"]
E --> F["Upgrade: link the domain with StudioWebPortalAccess ENABLED"]
F --> G["Users work in both interfaces"]
G --> H["Set StudioWebPortalAccess DISABLED"]
classDef warn fill:#FEF2F2,stroke:#D13212,stroke-width:2px,color:#991B1B
classDef ok fill:#F0FFF4,stroke:#1D8102,stroke-width:2px,color:#145202
class C warn
class H okReadiness report
The script below inventories a SageMaker AI domain before an upgrade and lists what to review. It is read-only: it calls DescribeDomain, ListApps, ListUserProfiles and ListSpaces, follows pagination and uses adaptive retries for large domains. A Studio Classic finding is a blocker; VPC-only networking, custom images, lifecycle configurations and active Canvas or RStudio apps are review items. The exit code is 1 when there is a blocker, which lets a platform team run it in a pipeline across many domains.
"""Read-only upgrade-readiness report for a SageMaker AI domain.
Before upgrading a SageMaker AI domain into SageMaker Unified Studio, this
script inventories what the domain uses (Studio Classic apps, custom images,
lifecycle configurations, VPC-only networking, Canvas, RStudio) and lists the
items to review. It never changes the domain.
Usage:
python readiness.py --domain-id d-xxxxxxxxxxxx --region eu-west-1
"""
from __future__ import annotations
import argparse
import json
import logging
import sys
from dataclasses import asdict, dataclass, field
from typing import Any
import boto3
from botocore.config import Config
from botocore.exceptions import BotoCoreError, ClientError
logger = logging.getLogger("smus-readiness")
# Studio Classic ran notebooks as JupyterServer and KernelGateway apps.
CLASSIC_APP_TYPES = {"JupyterServer", "KernelGateway"}
ACTIVE_APP_STATUSES = {"InService", "Pending", "Updating"}
@dataclass
class Finding:
severity: str # "blocker", "review" or "info"
area: str
detail: str
@dataclass
class Inventory:
domain_id: str
domain_name: str
auth_mode: str
network_access: str
default_landing_uri: str | None
studio_web_portal: str | None
unified_studio_settings: dict[str, Any] | None
user_profiles: list[str] = field(default_factory=list)
spaces: list[str] = field(default_factory=list)
apps_by_type: dict[str, int] = field(default_factory=dict)
custom_images: list[str] = field(default_factory=list)
lifecycle_config_arns: list[str] = field(default_factory=list)
def make_client(region: str):
# Adaptive retries absorb throttling on large domains with many apps.
cfg = Config(region_name=region, retries={"mode": "adaptive", "max_attempts": 10})
return boto3.client("sagemaker", config=cfg)
def _paginate(client, operation: str, key: str, **kwargs) -> list[dict[str, Any]]:
items: list[dict[str, Any]] = []
for page in client.get_paginator(operation).paginate(**kwargs):
items.extend(page.get(key, []))
return items
def collect(client, domain_id: str) -> Inventory:
domain = client.describe_domain(DomainId=domain_id)
user_settings = domain.get("DefaultUserSettings", {})
jupyterlab = user_settings.get("JupyterLabAppSettings", {})
kernel_gw = user_settings.get("KernelGatewayAppSettings", {})
images = [
img["AppImageConfigName"]
for img in jupyterlab.get("CustomImages", []) + kernel_gw.get("CustomImages", [])
]
lifecycle = list(
dict.fromkeys(
jupyterlab.get("LifecycleConfigArns", []) + kernel_gw.get("LifecycleConfigArns", [])
)
)
apps = _paginate(client, "list_apps", "Apps", DomainIdEquals=domain_id)
apps_by_type: dict[str, int] = {}
for app in apps:
if app.get("Status") in ACTIVE_APP_STATUSES:
apps_by_type[app["AppType"]] = apps_by_type.get(app["AppType"], 0) + 1
return Inventory(
domain_id=domain_id,
domain_name=domain.get("DomainName", ""),
auth_mode=domain.get("AuthMode", ""),
network_access=domain.get("AppNetworkAccessType", "PublicInternetOnly"),
default_landing_uri=user_settings.get("DefaultLandingUri"),
studio_web_portal=user_settings.get("StudioWebPortal"),
unified_studio_settings=domain.get("DomainSettings", {}).get("UnifiedStudioSettings"),
user_profiles=[
p["UserProfileName"]
for p in _paginate(client, "list_user_profiles", "UserProfiles", DomainIdEquals=domain_id)
],
spaces=[
s["SpaceName"] for s in _paginate(client, "list_spaces", "Spaces", DomainIdEquals=domain_id)
],
apps_by_type=apps_by_type,
custom_images=sorted(set(images)),
lifecycle_config_arns=lifecycle,
)
def assess(inv: Inventory) -> list[Finding]:
findings: list[Finding] = []
if inv.unified_studio_settings and inv.unified_studio_settings.get("ProjectId"):
findings.append(Finding("info", "status", "Domain is already linked to a Unified Studio project."))
classic = {t: n for t, n in inv.apps_by_type.items() if t in CLASSIC_APP_TYPES}
landing = inv.default_landing_uri or ""
if classic or landing.startswith("app:JupyterServer"):
findings.append(Finding(
"blocker", "studio-classic",
f"Studio Classic is still in use (active apps: {classic or 'none'}, "
f"default landing: {landing or 'unset'}). Migrate the domain from Studio Classic "
"to Studio first; the Unified Studio upgrade starts from SageMaker Studio.",
))
if inv.network_access == "VpcOnly":
findings.append(Finding(
"review", "network",
"Domain runs in VPC-only mode. Confirm the subnets and VPC endpoints the Unified "
"Studio project will use before moving users.",
))
if inv.custom_images:
findings.append(Finding(
"review", "images",
f"Custom images attached: {', '.join(inv.custom_images)}. Launch each one in a test "
"space from Unified Studio before migrating the users who depend on it.",
))
if inv.lifecycle_config_arns:
findings.append(Finding(
"review", "lifecycle",
f"{len(inv.lifecycle_config_arns)} lifecycle configuration(s) attached. Run them in a "
"test space; prefer moving package installs into the image.",
))
for app_type in ("Canvas", "RStudioServerPro", "RSessionGateway"):
if inv.apps_by_type.get(app_type):
findings.append(Finding(
"review", app_type.lower(),
f"{inv.apps_by_type[app_type]} active {app_type} app(s). Check how these users will "
"reach the tool after the upgrade before disabling Studio access.",
))
findings.append(Finding(
"info", "scope",
f"{len(inv.user_profiles)} user profile(s) and {len(inv.spaces)} space(s) would be imported.",
))
return findings
def main(argv: list[str] | None = None) -> int:
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument("--domain-id", required=True)
parser.add_argument("--region", required=True)
args = parser.parse_args(argv)
logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
try:
inv = collect(make_client(args.region), args.domain_id)
except ClientError as exc:
logger.error("AWS error: %s", exc.response.get("Error", {}).get("Message", exc))
return 2
except BotoCoreError as exc:
logger.error("SDK error: %s", exc)
return 2
findings = assess(inv)
json.dump({"inventory": asdict(inv), "findings": [asdict(f) for f in findings]},
sys.stdout, indent=2, default=str)
sys.stdout.write("\n")
return 1 if any(f.severity == "blocker" for f in findings) else 0
if __name__ == "__main__":
sys.exit(main())The items it flags are the ones that differ between teams. Custom images and lifecycle configurations attached to a domain should be launched in a test space in the target project before the users who depend on them move, and VPC-only domains need the project’s subnets and endpoints checked first, because a project provisions its own security groups through the Tooling blueprint.
New starts
For a team without an existing domain, November 2025 changed the starting point. One-click onboarding, available from the SageMaker, Athena, Redshift and S3 Tables consoles, creates an IAM-based domain and project from an existing IAM role, with default notebook and compute resources, and carries over existing permissions from the Glue Data Catalog, Lake Formation and Amazon S3. The new serverless notebooks include the SageMaker Data Agent, which generates SQL, Python or Spark from a natural-language prompt using the catalog’s schemas and relationships as context.
Platform teams that need standard project environments can define their own blueprints as CloudFormation templates, generally available since September 2025, and attach extra IAM policies to the project role through them, rather than editing roles by hand after each project is created.
Security and compliance
- The project role is the unit of access. Review it like any other workload role: what the Tooling blueprint attached, what custom blueprints add, and what Lake Formation has granted to it.
- Per-user attribution depends on the domain type. In an IAM-based domain, everyone in a project acts through the same role. For regulated data where each query must be traceable to a person, use an Identity Center-based domain.
- Long-running jobs keep corporate identity. Since November 2025, Unified Studio supports long-running sessions with corporate identities through IAM Identity Center trusted identity propagation.
- CloudTrail still records the underlying service calls. Unified Studio adds a project context; it does not replace the CloudTrail, Athena query history or Redshift audit logs that compliance teams already collect.
Lake Formation column-level and row-level permissions on Glue Data Catalog tables apply to every tool that reads through the project role, which is the main reason to bring regulated datasets into a project rather than reading S3 paths directly. Grant regulated tables to a dedicated project, keep the project small, and record approvals in the catalog’s subscription workflow so the grant has an owner and a reason.
Cost
There is no separate fee for Unified Studio. Each AWS service used through it is billed at its own price, and core setup requests are free; quick setup adds the cost of any networking resources AWS creates for you. The SageMaker Catalog has its own meter.
| SageMaker Catalog item | Free each month | Price after the free amount |
|---|---|---|
| API requests (core APIs such as CreateDomain, CreateProject and Search excluded) | 4,000 | $10 per 100,000 |
| Metadata storage | 20 MB | $0.40 per GB |
| Compute | 0.2 compute units | $1.776 per compute unit |
Worked cell: a domain that makes 104,000 catalog requests in a month pays for 100,000 of them, 100,000 ÷ 100,000 × $10 = $10. For most ML teams the catalog line is small next to notebook instances, Spark and endpoints, which cost the same as they did before Unified Studio.
Production considerations
- Upgrade one domain at a time. Keep
StudioWebPortalAccessatENABLEDuntil the users of custom images, Canvas and RStudio have confirmed their path, then disable it. - Keep pipelines in code. SageMaker Pipelines, the model registry and endpoints are SageMaker AI resources with the same ARNs whichever studio created them; CI/CD that calls those APIs does not change.
- Standardise with project profiles. Decide which blueprints each profile enables, so a SQL analytics team does not receive EMR and Bedrock resources it will not use.
- Check Regions. Unified Studio launched in 12 Regions at general availability; confirm yours before planning.
Decision framework

Start new work in Unified Studio. A new data and ML platform on AWS should begin with a Unified Studio domain: Identity Center-based if per-user attribution matters, IAM-based for the fastest start. Upgrade existing SageMaker Studio domains once the readiness report shows no blockers and the review items have been tested in a project space. Finish Studio Classic migrations first; they are a prerequisite, not an alternative.
The decision changes if your ML platform runs mostly outside SageMaker Studio, for example training on EKS with notebooks in a self-managed JupyterHub. Then Unified Studio’s value is the catalog and governed data access, and the upgrade path for SageMaker AI domains does not apply.
The readiness script was tested with Python 3.13 and boto3==1.42.76 (released 25 March 2026). Five tests pass using botocore’s Stubber, which validates each request and response against the SageMaker API model in that release, including the UpdateDomain request with UnifiedStudioSettings. The script was not run against a live AWS account. Catalog prices were read from the SageMaker pricing page in November 2026.
Key takeaways
- Unified Studio, generally available since 13 March 2025, is one environment over EMR, Glue, Athena, Redshift, Bedrock and SageMaker AI; the services underneath run and bill as before.
- A project has one IAM role and one S3 path, and every tool in it reads data through that role, so Lake Formation and IAM grants to the project role are what to review.
- Existing SageMaker Studio domains can be upgraded in place since June 2025, with both interfaces available until an administrator disables Studio access.
- Studio Classic domains must migrate to Studio first.
- IAM-based domains and one-click onboarding, added in November 2025, are the fastest start; Identity Center-based domains keep per-user identity and the full governance set.
Have you upgraded a SageMaker AI domain into Unified Studio yet, and what did your readiness check turn up? Share it in the comments.
The complete sample for this article is on GitHub: nithinmohantk/blog-samples-working-repo/smus-upgrade-readiness. Clone it with git clone https://github.com/nithinmohantk/blog-samples-working-repo.git and open the smus-upgrade-readiness folder. Its README says how to run it and what has been verified.
Glossary
- SageMaker Unified Studio
- A single web environment for data and AI work that brings together EMR, Glue, Athena, Redshift, Bedrock and SageMaker AI.
- SageMaker AI
- The name, since December 2024, for SageMaker’s original machine learning capabilities: training, pipelines, the model registry and endpoints.
- Domain
- The top-level Unified Studio container for users, the catalog and projects, built on Amazon DataZone.
- Identity Center-based domain
- A domain whose users sign in through AWS IAM Identity Center.
- IAM-based domain
- A domain whose users authenticate through federated IAM roles; all users in a project share the role’s permissions.
- Project
- A workspace that bundles members, tools, one IAM role and one S3 location.
- Project profile
- A template listing the blueprints a new project deploys.
- Blueprint
- A CloudFormation-based definition of resources for a project; the Tooling blueprint is always deployed first.
- Project role
- The IAM role every tool in a project uses to reach data and services.
- SageMaker Catalog
- The governance layer for publishing, finding and subscribing to data and AI assets.
- Studio Classic
- The original SageMaker Studio interface, based on JupyterServer and KernelGateway apps.
- UnifiedStudioSettings
- The SageMaker AI domain setting that links a domain to a Unified Studio project.
References & Further Reading
- → Amazon SageMaker Unified Studio is now generally available— Announcement, 13 March 2025
- → Accelerate analytics and AI innovation with the next generation of Amazon SageMaker— What Unified Studio brings together
- → Upgrade experience from SageMaker Studio to SageMaker Unified Studio— Announcement, 6 June 2025
- → UnifiedStudioSettings API reference— Fields that link a SageMaker AI domain to a project
- → Migration from Amazon SageMaker Studio Classic— Classic-to-Studio steps and support dates
- → Tooling blueprints in SageMaker Unified Studio— Project roles and resources the Tooling blueprint creates
- → Upgrade Amazon DataZone domains to SageMaker unified domains— Roles required and the V1 to V2 domain change
- → One-click onboarding, serverless notebooks and AI agents in SageMaker Unified Studio— November 2025 launches for IAM-based domains
- → Long-running sessions with corporate identities— Trusted identity propagation, 20 November 2025
- → Amazon SageMaker pricing— Unified Studio and SageMaker Catalog pricing
- → Sample code for this article— Upgrade-readiness report and tests
Discover more from C4: Container, Code, Cloud & Context
Subscribe to get the latest posts sent to your email.