PLOT Studio handbook

Build a site visually, give it behavior with Blueprint, and export the finished project. Follow the handbook from a blank page or jump straight to a recipe.

Start a project

Use Open Studio in the header. If Studio asks you to sign in, use the access password supplied by the site owner. The editor opens the active draft for the current browser. Use the menu beside the PLOT logo to rename, create, import, or open a different project.

  1. Open the project menu and choose New blank project if you are building a separate site. Use Download project file first if you want a checkpoint of the current work.
  2. Choose Rename project and give the new site a name you will recognize in the browser and on the server.
  3. Open Design, then Pages. List the pages visitors will need and decide where each primary button should take them.
  4. Make one working page before styling the entire site. Add a heading, a paragraph, and one button, then verify the page in Preview.

The four editor views have different jobs. In Design, arrange page blocks and edit their content and appearance. In Logic, connect triggers and actions. In Data, define fields, add records, and decide which operations visitors may call. In Code, inspect the generated site files and optionally add site-wide CSS or JavaScript. The built-in blocks and nodes are enough to complete the standard recipes in this guide.

To learn from a finished layout, choose Open PRÓG demo. To inspect a working graph that writes records, choose Open form + database demo. Each command opens an example project in the current session. Check your active project name before continuing after a demo.

Pages and navigation

Choose Pages in the Design library and select Add page. Enter the page name and check the URL slug. Start with a blank page or select a Product landing page, Portfolio, Documentation, or Contact template. Templates give you editable blocks and placeholder content. Replace every example heading, link, email address, and form instruction before exporting.

The home page exports as index.html. A page with the slug services exports as services.html. Keep slugs short and unique. Changing a slug after you distribute the site changes its exported filename. Update any manually entered links to the old path and any external links under your control.

Make routes easy to test

Add a Navigation block near the top of the page. Its Content tab includes a brand name, links, and an optional button. Turn on Add pages automatically to include project pages in menus that should follow the page list. Use the manual list when you want a specific order, an external destination, or shorter menu labels. Each line uses a label and URL separated by a vertical bar.

Home | index.html
Services | services.html
Contact | contact.html

For a link within the same page, select the destination section or heading and set its Anchor ID to a simple value such as pricing. Enter #pricing in the button or link URL field. Add a Footer for links people may look for after reading. In Preview, follow the same routes a visitor would take, including your return path to Home.

Use normal links for navigation. A button that changes something on the current page can keep the default # destination and use a Click node. Give it a label that describes the action, such as “Show pricing details” or “Copy reference number.”

Design with blocks

Open Elements in the Design library. Click an element to add it or drag it onto the canvas. Use Section to group a region of the page and Columns for content that belongs side by side. Use Layers to see the hierarchy. A block nested inside a container moves with that container. Shift-drag a block into a supported container when you want it to become a child.

Click a block on the canvas or choose it in Layers to inspect it. Double-click supported rendered text to edit it on the canvas. Use Content to change a block's written copy, labels, links, and other settings. Use Style for layout, dimensions, spacing, colors, typography, borders, and shadow. The available Content controls depend on the type of block.

  • Hero, Heading, Text, Link, Button. Use a single clear opening heading. Give later sections heading levels in reading order. Write button labels that describe the destination or action.
  • Feature, Card, Quote, FAQ, Table, Callout. Match the block to what the reader needs. A FAQ suits short questions, while a Table makes rows with the same attributes easier to compare.
  • Form, Input, Select, Toggle. A Form can show preset fields and contain child controls. Give controls stable field names before connecting them to logic or data.
  • Image, Gallery, Video, Audio. Use direct media URLs, meaningful text alternatives, and captions where they help readers understand the material.

Use Site themes in the project menu to set a coordinated baseline. For a specific block, adjust its width, padding, or type only when the design calls for a local variation. A width of 100% lets a block follow its container. A max width can keep reading text comfortable on wider screens. Padding controls space inside the block, while margin controls distance from neighboring content.

When an edit lands in the wrong place, use Undo in the Design toolbar. Before larger changes, download a project file. A known working copy makes it easy to compare which change affected the page.

Responsive layouts

Use Desktop, Tablet, and Phone in Design to work at different widths. Start by getting the order and content of the page right. Then set overrides for layout changes that are specific to smaller screens. The inspector distinguishes inherited values and local changes. A phone override is useful for stacking content, reducing a large heading, or changing spacing on a crowded call to action.

  1. Check Desktop first. Review the overall hierarchy, the width of long paragraphs, and the placement of the primary action.
  2. Check Tablet. Look for a navigation label breaking onto a second line, a narrow sidebar, or a three-column section that needs more room.
  3. Check Phone. Verify that body text can be read without zoom, buttons fit ordinary labels, and the page can be navigated by touch.
  4. Open the interactive Preview at the same widths. Test the navigation, menu, form controls, and logic with real clicks and keyboard actions.

Fix an overflowing item at its source. Check the child width and minimum width, then inspect its parent's layout, wrap, or column settings. Reduce unnecessary fixed dimensions before hiding the overflowing area. If an image crop cuts off important content, adjust its fit or change the aspect ratio. Test a long label and a realistic paragraph, because placeholder content often hides wrapping problems.

Images by URL

New image entries and replacements use the direct HTTP or HTTPS address of an image. This applies to the Image block, image fields inside Hero and Card blocks, Gallery entries, and a Video poster. An image added by URL stays on its external host, which continues to serve it when people visit your exported site.

  1. Open the image on the source site and copy its actual image address. A sharing page, a search results page, and the URL from a private dashboard often point to HTML rather than the image file.
  2. Open the copied address in a fresh browser tab. If access depends on your account, test it in a private window that has no active session for that host.
  3. Open the block's Content tab and paste the full address into the image field. Use HTTPS for an HTTPS site so the browser can load it securely.
  4. Add concise alt text for an image with information. Describe the part that matters to the reader. Put credits, dates, and extra context in the caption where useful.
  5. Verify the image in Preview at Desktop and Phone widths. If the file disappears, test the exact address again. Some hosts expire links or restrict use from other websites.

Gallery entries use one image per line. Put the direct image URL first, then optional alt text and a caption separated by vertical bars. The addresses below are placeholders. Replace each one with a real URL before testing.

https://images.example.com/lobby.webp | Lobby with oak benches | Main entrance
https://images.example.com/stair.webp | Daylight on a brick stair | Stair detail

Prefer stable addresses over temporary signed links. The ZIP preserves remote image references, so the same host must serve them after launch. For an image that changes in response to a visitor's choice, give the Image block a working default URL first, connect the behavior in Logic, and verify both sources separately.

The Blueprint workspace

Blueprint is the workspace for actions your site takes while someone uses it. The canvas holds nodes and connecting wires. The inspector shows settings for the selected node. Add a node from the picker and search by its label or job. Search for “submit” if you want the event that starts when someone sends a form. Search for “visibility” if you want to show or hide a block.

The node reference lists every available node with its purpose and typed ports. Open it beside Studio when you need the exact name of an input or output.

Move around the graph

Drag with the right mouse button to pan in any direction. Use the wheel to zoom toward the pointer. Fit graph brings everything into view, and Frame centers your selection. Zoom in when you need to work precisely on a port. On touch, drag an empty part of the canvas to pan.

Blueprint canvas controls
GestureAction
Right-dragPan the canvas horizontally and vertically.
Right-clickOpen the context menu near the pointer.
Mouse wheelZoom around the pointer.
Left-drag empty canvasDraw a selection rectangle around nodes.
Arrow keysPan when focus is on the canvas itself.
F or HomeFrame the selection.
N / COpen the node picker / add a comment.
Alt + click a portBreak the connections on that port.
Drag an output to blank spaceFind a compatible node and connect it from the source port.

Organize a growing graph

Use Find to locate a node already on the graph. Use Add node when you need a new one. Click the minimap to jump to another area. Collapse Details for more room, or use Focus to give the canvas the screen. Open Details again when you need to edit the selected node.

Box-select related nodes before applying commands to the set. Drag a selected node to move them together. Use Arrange to align the selection, or add a comment around it to name the steps. Give significant nodes a clear title or note in Details. Lock nodes that should stay in place while you arrange their neighbors. Open Graph → Bookmarks to save the current view and jump back to a named area later.

Use the selection commands to copy, duplicate, or delete a group. Copy and paste let you reuse a pattern elsewhere on the canvas. Verify the destination blocks and tables after pasting, especially if the pasted routine is meant for another page. Select a connection to inspect its endpoints, jump to the source or destination, or remove that wire.

A readable graph follows the order of the interaction. Put the event on the left, steps that prepare data in the middle, and the visible result on the right. Place an error branch below its success branch. Use distinct paths for separate visitor actions, even when both update the same block.

Events, wires, and values

An event node is the entry point of a graph. Click starts from a page block, Input change starts when a field changes, Form submission collects the fields of a form, and Page load starts when a page opens. Some events let you select a page or a particular form field. Choose an explicit target whenever the interaction belongs to one page or control.

Execution wires

They determine when things happen. Connect an event's Run output to the first action, then follow its Next, Yes, No, Success, or Error output as appropriate.

Value wires

They carry information such as text, a number, a record, or an array. Connect the output of the node that supplies the value to a compatible input on a later step.

Provide both kinds of wire when an action needs to run and receive input. For example, connecting a form's Fields to a later node gives that node the submitted object. The execution wire tells the later node when to process it. Values produced by an action become available after that action has run on the same branch. A Constant supplies a fixed value without an execution step.

Build one path at a time. First confirm the click or submit event is connected to the intended block. Then connect a visible outcome such as Set text, Change visibility, or Show notification. Use a condition when an interaction has more than one result. Attach feedback to both outcomes where the distinction matters to the visitor.

For repeated routines, create a Flow input, give it a clear name, and finish the routine with Return value. Call it from an event path with Run flow. Use For each item to apply a flow to items in an array. A flow can be tested on a simple example before you call it from several places. Use flow-run variables for values needed during that interaction and page-scoped variables for shared values while a page remains open.

Resolve missing targets and incompatible connections before exporting. Read the node and port labels rather than relying on the wire color alone. If a database or request node exposes both success and error, connect the success branch to confirmation and the error branch to useful feedback. Add Log value at the nearest step where you can check an unexpected input or output.

Control how often a path can run

Put Throttle flow before an operation that should run at most once in an interval. Put Run once per page before an action that should happen once until reload. Both expose Pass and Fail paths, so a skipped action can have its own behavior. Wait pauses a running flow for a configured delay. Timer after delay starts a separate flow once after page load. Timer interval starts a sequence of ticks and lets you limit how many ticks occur.

Blueprint validates graph size and puts limits on work at runtime. A graph supports up to 1,200 nodes and 6,000 wires. An individual run can use up to 8,000 steps within two minutes. HTTP request nodes support timeouts up to 30 seconds. Where bursts of events are expected, keep each path short and use throttling to control repeat calls. Use the Preview Console to see where a path reached a limit or encountered an error.

No-code recipes

Use the recipes as patterns. Create the target blocks in Design first, give their content recognizable labels, then add the nodes. Test each flow in Preview before combining it with another interaction.

Reveal details with a button

  1. Add a Button with the label “Show details” and keep its URL at the default #. Add a Text block immediately below it containing the details.
  2. In Logic, add Page load, select the current page, and connect its Run output to Change visibility. Target the Text block and set the mode to Hide.
  3. Add Click and target the Button. Connect Run to a second Change visibility node, target the same Text block, and choose Toggle.
  4. Open Preview. At first, the details should be hidden. Click once to show them and again to hide them. Reload Preview and check the starting state again.

For details that can simply expand and collapse by themselves, try a FAQ block. Use Blueprint when the trigger lives elsewhere or opening the details also changes another block.

Mirror a field into live page text

  1. Add an Input with the label “Display name” and a Text block with the content “Your name appears here.”
  2. Add Input change in Logic and select the Input block. Add Set text and choose the Text block as its target.
  3. Connect the event's Run output to Set text's execution input. Connect its Value output to the Set text value input.
  4. In Preview, type a name and then delete it. To display a fallback for an empty value, put a Condition before the Set text actions and add a branch with your fallback sentence. Test both branches.

If you put a group of inputs inside a Form and target the Form in an input event, check the Form field setting. The event can react to one specific control or to changes anywhere inside the form.

Show a message based on a choice

Add a Select block with the options Product | product and Support | support on separate lines. The first part is visible to the visitor. The second part is the value supplied to the graph. Add an output Text block so both branches have somewhere to write their result.

  1. Target the Select with Input change and add a Condition.
  2. Connect Run to the condition's execution input and Value to the condition's value input. Set its comparison to Equals and enter support as the comparison value.
  3. Use one Set text node for Yes and another for No. Both can target the output Text block with different messages.
  4. Test Product, Support, and the initial empty state. Set a default selection or an opening message if visitors need to see a meaningful result before changing the field.

Save a form submission to a table

To inspect the entire workflow first, choose Open form + database demo from the project menu and open Logic. The mapper in the example connects its form fields to the sample table.

Create a Form with two required controls. Give the name field the internal name name and the email field the internal name email. In Data, create an Inquiries table with required Name and Email fields. Copy the actual field IDs from the Fields tab. Field IDs stay stable when display labels change.

In Logic, add Form submission and target the Form. Add Map object fields. Connect the event's Run output to the mapper's execution input and its Fields output to the mapper's Source input. Select the mapper, open Field map in Details, and use Add field mapping to create these two rows. Replace the examples with the field IDs you copied.

  • Destination key: your Name field ID. Source field path: name.
  • Destination key: your Email field ID. Source field path: email.

Add Create record and choose Inquiries as the target table. Connect the mapper's Success port to Create record's execution input and its Result port to Field values. If you change a form field name, update its matching value in Field map.

Connect Create record's Success and Error ports to separate feedback actions. The success message can say “Your inquiry was received.” The error message can say “Your inquiry could not be saved. Try again.” Try leaving a required field empty to check the browser's form validation.

In the table's API access tab, enable the operation visitors need for the submission. For a contact form, Create records is usually enough. To check the database's Error branch, test a valid submission with Create records off and Enforce public API permissions on. Then enable Create records and test again with Preview open on the updated draft. Use Keep test records when you want a successful Preview submission to appear in your draft.

Validate a quantity and calculate a total

Add an Input labelled “Quantity” with type Number and a Text block for the total. You will use a fixed sample unit price of 25. Start with Input change for the quantity. Connect its value to Convert to number and connect the execution ports.

  1. Connect the converter's Success and numeric Result to Require number range. Set the minimum to 1 and maximum to 50.
  2. Continue through Multiply numbers and pass the validated number into Number A. Enter 25 for Number B.
  3. Pass the result into Format number and then Set text. Connect each preceding Success port and matching Result port so the output is available when Set text runs.
  4. Connect the converter and range check error paths to feedback such as “Enter a quantity from 1 to 50.” Check blank input, 1, 50, and 51 in Preview.

Use Condition or another check when the next step depends on a comparison. Use Require value, Require email, and Require text length for constraints visitors should fix before a later step runs.

Switch an image with a selector

Add an Image block with a working default address and a Select block. Give each option a descriptive label followed by its own direct URL. Use Committed field change and target the Select. Wire its Run to Set image URL, select the Image as the target, and wire Value to URL. When each choice needs different alt text, take the successful path to Set image alternative text and pass a description that corresponds to that choice.

Try both choices on Phone and Desktop. The URL action validates address format. Preview is still needed to see whether the external host serves the file.

Data and API access

In Data, use New table to organize records that share a purpose. Add fields in Fields, including types such as text, email, number, date, boolean, and JSON. Mark a field required when every row needs it. Add a few representative records with Add record to check the structure before importing a large list or wiring up a form.

Use Import CSV after defining the fields. Align column headings with the target fields and start with a small sample. Open the imported rows and check punctuation, dates, empty cells, and numeric values. Use Export CSV when you need a copy of a table's draft records. Exporting a CSV and downloading the entire site ZIP serve different purposes.

Choose the operations a visitor may use

Open API access for the individual table. Every operation starts off. List records returns a collection, Read one record returns a row by its ID, Create records inserts, and update or delete changes stored records. Enabling an operation exposes it to visitors of the exported site. A contact inbox generally needs Create records. A public directory generally needs List records. Give a table only the access its public feature needs.

The exported runtime uses SQLite and applies the table schema and public operation settings. For visitor accounts or access that depends on an individual user's identity, arrange that in the published application's backend. Avoid using a public list operation for an inbox containing private submissions.

Browser requests run in the visitor's browser. Anything configured in a request or included in the public JavaScript can be inspected. For API credentials that must stay private, use a backend endpoint you control. For no-code projects, choose public request endpoints intended for browser use or use the included table runtime.

Backend and private hosting

Open Backend → Workflows to edit the logic that runs on the server. A workflow starts when the server receives an HTTP request with a matching method and path. Select New to add a route. The first endpoint starts at GET /api/status with a JSON response. Use Send request to see its status, body and execution trace.

Build a request flow

  1. Set a path under /api/ and choose a method. Use :id in a configured path to match a value such as /api/products/123. Enter the real value when testing.
  2. Use Add node and search for the operation you need. Each node lists its fields, expected input and purpose. Use the Details panel to name the node and choose what should run on success or error. Nodes without a manual destination run in order.
  3. Choose From workflow to use request data or a previous node result. A path such as request.body.email picks one field. A result can feed a decision, a database operation, or the final response.
  4. Finish with a JSON or text response and set an appropriate status. For a write endpoint, exercise valid data, a missing field, and a failed write. Use Validate to check branches and references before publishing.

Backend nodes can access the draft's table definitions and data. To insert a row, pick a table, then supply an object keyed by its field IDs. Server-side table actions follow the workflow's route access policy. The separate table API uses the permissions configured in Data.

For a button or form on the website, use Call backend route in Logic. For example, a form can take its Fields output, call a POST endpoint, and display a success message for the returned body. The server route can validate the body, write to SQLite, and return a result. Preview runs requests against temporary draft data. Publish a private release to test persistent writes and registered services.

Publish a private site

  1. Open Backend → Hosting or select Host this project in the project menu. Choose a site address made from lowercase letters, numbers, and dashes.
  2. Choose whether to seed the new database with draft records. Select Publish site. Open the resulting link under /studio/sites/your-site/. The site requires the Studio password and keeps a dedicated database on the VPS.
  3. To update the pages and workflows, select the same hosted site and publish the current draft to it. Existing records remain in that site's database. If a schema change is incompatible, the release reports the issue. Unpublish takes the address offline and keeps its database.

For a hosted service endpoint, choose API key required. Use Copy API key in Hosting and send it from your server client in an Authorization: Bearer … header. The direct endpoint follows the hosted site address, for example /studio/sites/your-site/api/status. Keep API keys in the caller's server environment.

Connections, registered programs, and Rust

Use Backend → Connections to register an HTTP address under a short name. Choose its allowed method and optionally set a bearer token. Use Allow this address on the private network for a service on your own network or VPS. Configure the connector node with that name. Connectors use a registered destination and send request fields as data.

The registered task node runs a named program from the server configuration and passes its input as JSON. Server clock is available as a simple test. A VPS administrator can register additional labels and fixed argument lists in PLOT_SERVER_TASKS or a JSON file designated by PLOT_SERVER_TASKS_FILE. Each task entry has a label and an argv array starting with the program's absolute path.

Rust operations call the compiled helper on the VPS from the workflow. Choose an operation from the Rust category and configure its inputs in the same Details panel. For a standalone ZIP, set up the bundled helper with the command in BACKEND.md. Store credentials on the server and verify the success and error branches on your private hosted link.

Test in Preview

Select Preview in the header or Test site from Logic. Pick the page and device in the Preview toolbar. The Preview is interactive, so click actual buttons, tab through form inputs, use navigation links, and check the page after a reload. Start with the expected path, then test what happens when a field is empty, a request fails, or permissions are off.

  1. Open Show preview console. Add a Log value node after an event or data action if you need to inspect the value carried by a wire.
  2. Run an interaction once and read the messages. Compare the result to the event target and the branch you expected. If nothing appears, check the event, the execution wires, and whether you opened the intended page.
  3. Use Restart preview when you need the initial page state again. Rerun the same actions after each change so the effect of that change is easy to see.
  4. For a database test, leave Enforce public API permissions enabled to verify how the exported runtime will treat requests. Use Keep test records only when you want the temporary data in the draft.

For a test that intentionally uses an external service, open the Preview Console and enable Allow fetch and sockets. This rerenders the preview page. The setting starts off each time you open Preview. SQLite preview requests continue to use the internal preview bridge. Check the success and error branch of every step that calls a remote service. Confirm HTTPS, the request method, response body format, and that the service permits browser requests from your site's origin. Test again from the actual export, because the preview and published site can have different origins.

After testing, open Graph → Execution trace to see recent node steps, log messages, and faults. Select a trace entry to locate its node. Write down what passed in observable terms. “The button changed the text,” “the form added one sample record,” or “both page links opened the intended destination” helps the next person verify the work quickly.

Save, export, and host

Saved locally refers to the draft in this browser. Use Download project file to keep a portable editable copy. Use Save to server to keep a server copy, then use Server projects to retrieve it later. When you want a separate version of a server project, use its Save as copy operation.

Use Export for the finished website. A static ZIP contains HTML pages, styles, JavaScript, and packaged local assets when present. It retains remote image addresses. For a site with a table, the ZIP also contains a Python runtime and database schema. The SQLite export dialog gives you the option to include records as seed data. Leave that option off for a clean database or when the draft contains test or private records.

Check the exported files

Extract the ZIP to a new folder. For a static export, serve the files with a static host and make index.html the home page. To check it locally, open a terminal in the extracted folder and run the command below, then visit http://localhost:8080/.

python -m http.server 8080

For an export with Data, start the included runtime from the extracted folder. The bundled DATABASE.md describes the API, permissions, and runtime files. Use the runtime behind HTTPS when deploying a data-backed site.

python runtime.py --port 8080

Follow the primary links and repeat the main interaction in the extracted export. If you use a database, submit a test record, confirm it persists, and check that the allowed operations match your intent. A site can be ready for export even when its production hosting is a separate task.

Guide for AI operators

This workflow is for an assistant using the browser to build in Studio. Treat the user's page brief, content, and asset list as the scope. Use the editor's normal controls, blocks, styling fields, and built-in nodes. Preserve existing work by checking the current project before creating, importing, or replacing a draft.

  1. Establish the project. Read the active project name and page list. Create a checkpoint if the draft is already in use. Keep a short checklist of intended pages and actions.
  2. Build the page structure. Create page names and slugs, add the navigation, and place sections in reading order. Use realistic copy from the brief and wire basic navigation before adding conditional behavior.
  3. Keep inputs stable. Set clear labels and field names. For images, use only approved direct image URLs from the brief and verify each one loads. Keep URLs and copy editable in the appropriate Content tab.
  4. Connect interactions. Locate the right page and target block in each node. Keep a record of the event, outputs, and expected behavior for each route. Use the recipes as building patterns.
  5. Test with real controls. Check the main path, smaller devices, typing and tab order where relevant, and the error path of a data action. Use sample data with no private information.
  6. Save and hand off. Save the editable project in the requested location. Export when requested. In the handoff, list the pages created, interactions verified, and any assets or settings that still need the user.

A useful brief specifies which project to open, the style, pages, and at least one behavior that can be tested. The example below is ready to adapt.

Build a service studio site in PLOT using the visual editor and built-in nodes. Create Home, Services, and Contact pages. Use the copy and image URLs I supplied. On Contact, save name and email to an Inquiries table and show separate success and failure messages. Check the result in Desktop and Phone Preview, then save a server copy and tell me what passed.

If a step behaves unexpectedly, inspect the visible state before repeating it. Check the form field names, the target block, the menu item's destination, and the latest console messages. Report the concrete gap when a required service, image URL, or project is unavailable. Keep the handoff clear enough that someone else could reproduce the test through the editor.

Troubleshooting

The graph runs without a visible result.
Check the selected event target, page, and execution wires. Add Log value after the event to verify it fires. Open the action settings and check the target block and value input.
A value is missing or appears on the wrong branch.
Check that the producer runs before the consumer on that route. For an object or array, confirm the property path or item index you are using. Check input type and make conversions explicit.
A request or database operation fails.
Connect the Error branch, look at the Preview Console, and reproduce the smallest failing request. For a record write, verify required fields, field IDs, field types, and table permissions.
A picture loads for you but disappears for a visitor.
Open the direct address in a private browser window. Check HTTPS, link expiration, and whether the host permits displaying the image on other sites.
Phone layout shifts or scrolls sideways.
Inspect the widest child. Check its fixed width, minimum width, long unbroken text, and the column or flex layout of its parent. Retest in Preview at Phone width.
The ZIP opens but the form cannot write records.
If the ZIP includes SQLite, run the included runtime and visit it through its HTTP address. Confirm the table permits the public operation and that the exported schema contains the fields used by the graph.

Background reading for the graph interaction model is available in the Unreal Engine Graph Editor documentation.

Back to the handbook contents