Data Authorization
The Spark-engine layer of access control. Intercepts SQL, DataFrame, and DDL/DML operations before execution and blocks anything that targets data outside the user's data plane assignments. See Data Authorization.
Data plane
A platform-managed collection of data — tables, S3 paths, streaming sources — belonging to a specific business domain or team. The unit of access on the platform: you are either assigned to a data plane (full read + write) or not (no access). See Data Authorization.
Default kernel
The kernel a notebook gets without any runtime template attached. Runs on the workspace's default Jupyter compute pool with a fixed-size driver and 5 fixed Spark executors. See Runtime Attachment in Notebook Workspaces
Driver
The Spark process that runs your notebook code, schedules tasks, and collects results. On Syntasa, the driver runs inside the kernel pod itself.
Executor
A Spark worker process that runs tasks the driver schedules. On the default kernel you get 5 fixed executors; on an attached runtime, the runtime template configures how many.
Init script
A bash script that runs on the kernel pod and on every Spark executor before your code does anything. Three layers: global (admin-set, applies everywhere), runtime (admin-set on a template, applies when attached), notebook (per-notebook, you set it from a toolbar button). Order: global → runtime → notebook. See Init Scripts & Dependencies.
JupyterLab notebook
A regular .ipynb file you create from the JupyterLab file browser. Lives anywhere in the workspace and does not appear in the Syntasa portal. Compare with Notebook card. See Notebook Cards vs JupyterLab Notebooks.
Kernel
The interpreter (Python or Scala) that runs your notebook cells. On Syntasa, every notebook has its own kernel pod; the kernel is per-notebook, not per-user. RTC means multiple users on the same notebook share one kernel.
Notebook card
A notebook that the platform tracks as a managed object — created in the Syntasa portal, listed alongside apps and dashboards, stored in the workspace's notebooks/ folder. Compare with JupyterLab notebook. See Notebook Cards vs JupyterLab Notebooks.
Notebook Output
The artifact a Notebook Process produces on a successful run: a preview of the executed notebook with all cells run and their outputs captured. Inspect from the workflow UI. See Notebook Process (Jobs).
Notebook Process
A Syntasa workflow process that runs a notebook non-interactively. One process type among many — same job orchestration model as Spark code processes and others. See Notebook Process (Jobs)..
Personal workspace
A workspace automatically created for every user. Visible only to you; useful for scratch work and anything you don't want cluttering a shared workspace. Compare with Group workspace. Notebook Workspaces.
Real-Time Collaboration (RTC)
Standard JupyterLab Real-Time Collaboration — when two or more workspace members open the same notebook, their edits, cursors, and cell outputs appear live in each participant's view. On by default. See Real-Time Collaboration.
Runtime instance
A live Kubernetes Spark cluster spawned from a runtime template. A dedicated template can have many instances; a shared template typically has one. Compare with Runtime template. See Runtime Attachment in Notebook Workspaces
Runtime template
An admin-defined recipe for a Kubernetes Spark cluster: container image, instance type and count (or autoscale range), idle timeout, and a shared/dedicated flag. You attach a notebook to a runtime template to upgrade from the default kernel. See Runtime Attachment in Notebook Workspaces
SecretString
A wrapper type that redacts itself in print and log output (**********). Returned by synutils.credentials, synutils.connections, and synutils.infrastructure for encrypted values. Call .get() to reveal the raw string for an SDK call. See Notebook Utilities (synutils).
Session Policy
The credential-scoping layer of access control on AWS. Generates temporary AWS credentials limited to the S3 paths and Glue databases of the user's assigned data planes — so direct boto3 calls and other non-Spark cloud access stay within the same boundary as Spark queries. See Session Policy.
Shared cluster (template)
A runtime template flagged so that multiple notebooks can attach to one instance. Each attached notebook still gets its own kernel pod and Spark driver — the underlying cluster compute pool is what's shared. Detach (don't Stop) when done to leave the cluster up for others. See Runtime Attachment in Notebook Workspaces.
Spark History Server
The standard upstream UI for Spark applications that have already completed. Each user sees only their own jobs (System Admins see all). Available at /spark-server on the Syntasa hostname. See Spark History Server.
Spark UI
The live Spark Applications UI for the application currently running on your kernel. Opens from the Spark icon on the notebook toolbar once the Spark session is ready. See Spark UI Access.
synutils
The unified utility namespace exposed in every notebook (Python attribute and Scala REPL alias). Modules: credentials, lib, notifications, connections, infrastructure, eventstores, datasets, spark, fs, files. See Notebook Utilities (synutils).
System Admin
A platform-level role that bypasses both Data Authorization and Session Policy. System Admins see all data and all jobs across the platform — needed for operations and debugging. Not assigned to regular users.
Workspace
A shared, persistent file system that opens in JupyterLab. Two kinds: group workspaces (admin-created, shared with a team) and personal workspaces (auto-created per user). The unit of access control on the platform Notebook Workspaces