Amazon SageMaker Unified Studio: Is This the End of Fragmented MLOps on AWS?

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.

Diagram of the SageMaker Unified Studio model: a domain with Identity Center or IAM identity and the SageMaker Catalog, a project created from a project profile with a project IAM role, and the tools in a project such as JupyterLab, serverless notebooks, the query editor, visual ETL, Spark, Amazon Bedrock, SageMaker AI and Amazon Q Developer
A Unified Studio project bundles people, tools and one IAM role. Every tool in the project reads data through that role, so Lake Formation and IAM grants decide what any notebook, query or job can see.

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?

ℹ️
TWO DOMAIN TYPES

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:

CapabilityService underneathNotes
JupyterLab and Code Editor spacesSageMaker AIThe same space types as SageMaker Studio, inside the project’s SageMaker AI domain
Serverless notebooks with Data AgentAthena for Apache Spark for Spark cellsAdded 21 November 2025; Python, SQL and Spark in one notebook
Query editorAthena, RedshiftSQL over Lakehouse tables
Visual ETL and workflowsAWS Glue, Amazon MWAAMWAA Serverless for IAM-based domains from November 2025
Generative AI appsAmazon BedrockKnowledge Bases, Guardrails, Agents and Flows
Model training and deploymentSageMaker AITraining jobs, pipelines, model registry, endpoints
Coding assistanceAmazon Q DeveloperFree 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).

⚠️
STUDIO CLASSIC FIRST

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 ok

Readiness 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.

Python187 lines
"""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.
⚖️
HEALTH AND PERSONAL DATA

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 itemFree each monthPrice after the free amount
API requests (core APIs such as CreateDomain, CreateProject and Search excluded)4,000$10 per 100,000
Metadata storage20 MB$0.40 per GB
Compute0.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 StudioWebPortalAccess at ENABLED until 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

Decision matrix for an existing SageMaker AI domain: Studio Classic still in use means migrate to Studio first; Studio with AWS images means upgrade into Unified Studio; custom images, lifecycle configs, VPC-only domains and Canvas or RStudio users mean test first; no domain yet means create a Unified Studio domain
Most domains already on SageMaker Studio can upgrade in place and run both interfaces during the move. Studio Classic domains have one migration to finish first.

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.

📝
HOW THIS WAS CHECKED

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.

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


Discover more from C4: Container, Code, Cloud & Context

Subscribe to get the latest posts sent to your email.

Written by

Nithin Mohan TK

Hello Namaste! 👋🏻 I'm an accomplished Enterprise Solution Architect & Engineering Leader with 20+ years of progressive experience architecting, building, and scaling transformative enterprise solutions. ⚜️ Solution Architect / AI & Cloud 📌 Galway, Ireland

Leave a comment

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.