Unify Logo Footer.svg
Unify Applications
Logo
Pages Overview

Pages Overview

Logo

7 mins READ

What Is a Page?

A page is the fundamental unit of navigation in a UnifyApps application. Everything a visitor sees at any given moment belongs to exactly one page. Your application is, at its core, a collection of pages connected by navigation.

Each page has its own URL, its own layout of blocks, and its own private state: parameters that arrive from outside the page and variables that are scoped to the page and reset every time the page closes. Pages do not share state directly — they communicate through inputs, outputs, and events.

Note: An application equals a set of pages plus navigation between them. If you have built with traditional web frameworks, a page in UnifyApps maps closely to a route — but with built-in state, typed parameters, and lifecycle events managed by the platform.

What a Page Bundles

Every page is a self-contained unit that brings together four things:

Bundle componentWhat it includes
An addressA slug that maps to a URL segment, plus an access setting (Private or Public).
Inputs and outputsTyped parameters the page accepts from the URL or from a navigation call; values the page publishes to its opener; named events the page can emit or receive.
VariablesNamed, typed values scoped exclusively to this page. Blocks read them and actions write them. Variables reset whenever the page opens fresh.
A layoutHeader, body, and footer regions on the canvas; an optional custom head for meta tags and scripts; optional custom code in header/footer slots; mobile system bar styling.

Note: A page does not own a data source directly. Data sources are attached separately and queried through the Data panel. The page's On Page Load trigger is the conventional place to fire queries that need to run when the page opens.

Page Lifecycle

When a visitor navigates to a page, the platform runs through a predictable initialization sequence. Understanding this sequence helps you know where to put each piece of logic.

  1. Resolve parameters from the URL: The platform reads the URL — both path segments and query string — and matches values to the page's declared parameters. Undeclared parameters are ignored. Type conversion runs: numeric strings become numbers, "true"/"false" become booleans, JSON text becomes objects or arrays.

  2. Apply variables' initial values: Each page variable's initial value expression is evaluated. Variables that reference page parameters at this point receive the resolved values from step 1.

  3. Render the layout: Header, body, and footer blocks render using the now-initialized parameters and variables. Blocks that depend on data sources that have not resolved yet render in their loading state.

  4. Fire On Page Load trigger: The On Page Load trigger fires. Any action chains attached to it execute — typically data source queries, variable updates, or conditional navigation. There is no automatic data fetch unless you attach it here or configure a data source to run on load automatically.

Warning: Navigating away from a page tears down its entire state. When the visitor returns — even via the browser back button — the page reinitializes from scratch. If you need state that survives navigation, store it in a URL parameter, a browser storage variable, or a server-side record.

The Navigator panel lists every page and module in your application as a tree. Pages can be organized into folders, and folders can nest inside other folders. The tree structure reflects the URL hierarchy of your application.

From the Navigator you can:

  • Click a page to open it on the canvas.

  • Drag pages to reorder them within a folder or move them between folders.

  • Right-click a page for options: rename, duplicate, move, or delete.

  • Create a new folder to group related pages.

Creating a New Page

Use the + New Page button in the Navigator panel or from the Pages menu in the top bar.

  1. Choose a starting point: Select a template from the gallery (pre-built layouts for common page types such as dashboard, form, detail view) or choose Blank Page to start with an empty canvas.

  2. Set the page name: The page name appears in the Navigator and becomes the default document title (shown in the browser tab). It does not affect the URL — the slug controls the URL.

  3. Set the parent folder: Choose which folder the page lives in. The folder determines the URL prefix for the page. A page at the root level has no folder prefix.

  4. Set the page slug: The slug becomes the URL segment for this page, displayed in the dialog as Page URL. Use lowercase letters, digits, and hyphens only. Changing the slug after sharing the link breaks any existing bookmarks or external references.

  5. Set privacy: Private (default): only signed-in users can access the page. Public: anyone with the link can access the page without signing in. Additional role-based permissions can be layered on top of this setting.

  6. Configure navigation options: Optionally add the page to your app's navigation menu, set a navigation icon, and choose where it nests within the menu hierarchy. These settings only affect automatically generated navigation components.

Page Settings Reference

After creating a page, open Page Settings from the top bar or by right-clicking the page in the Navigator. The settings panel is divided into several sections.

SettingDescription
Page SlugThe URL segment for this page. Changing this breaks existing external links. Only letters, digits, and hyphens.
Parent FolderWhich folder contains this page. Changing the folder changes the page's URL prefix.
PrivacyPrivate (requires login) or Public (open to all). Apply additional Permissions for role-based control.
Query ParametersDeclare typed page inputs here. Each input has a name and a type (String, Number, Boolean, Object, Array).
Document TitleWhat appears in the browser tab. Defaults to the page name. Can be a fixed string or a dynamic expression bound to page state.
EventsConfigure On Page Load, On Page Focus, and Keyboard Shortcuts triggers here.
PermissionsRole-based access rules layered on top of the Public/Private setting.
Custom CodeHeader and footer code slots for JavaScript or CSS that ships with this page.
Transition BehaviorMobile animation style when navigating to/from this page.

Pages connect to each other through navigation actions wired to events. The primary navigation action is Go to Page.

ActionDescription
Go to PageNavigate to a specific page in your app. Configure: target page, open in new tab, history mode (Push or Replace), page inputs to pass, and dynamic path param values.
Go to URLNavigate to an absolute or relative URL. Use for external links or links outside the app's page tree.
Navigate BackEquivalent to the browser back button. Pops the history stack.
Set URL ParametersUpdate query string parameters for the current page without a full navigation. Triggers a re-read of the updated parameters.

Go to Page — Option Details

OptionValuesEffect
Open in new tabtrue / falseWhen true, the target page opens in a new browser tab. The current page remains open.
HistoryPush / ReplacePush adds an entry to the history stack (back button works). Replace replaces the current entry (back button returns to the page before the current page).
Page InputsKey-value pairsValues passed to the destination page's declared inputs. Appear in the URL as query string parameters.
Dynamic ParamsKey-value pairsValues for dynamic path segments in the target page's folder hierarchy.

Topics in This Section

The Pages section of these docs covers everything you need to build, configure, and connect pages. Here is what each topic covers:

📁 Pages section — topic index

TopicWhat you'll learn
Page Layout & FoldersHeader/body/footer regions, drawer layout, custom head, folder types, folder redirects.
Parameters & RoutingDeclaring typed inputs, reading params in bindings, slugs, privacy, default pages, document title.
Page FunctionsNamed JavaScript functions on a page, automatic vs. manual run modes, app-level vs. page-level scope.