Tag: Innovation

A strong intake workflow goes beyond just having a public form

When a team requests an online form, they often need more than just the form itself.

Teams need a dependable way to gather structured information from people outside their system, reduce incomplete submissions, guide users through each step, and send the results into their internal workflow. That’s why Claris Studio forms deserve a closer look. Claris describes form views as multi-page web forms that can be shared with team members or anyone with the link, and public sharing doesn’t require sign-in. This combination of multi-page flow and easy sharing makes Studio a great choice for external intake.

Begin by dividing the process into clear stages

The real benefit of a multi-step form isn’t just appearance. It helps you organize the information you collect.

Rather than showing everything on one long page, you can split the process into steps like:

• contact information
• request details
• supporting information
• confirmation and submission

This approach makes the form clearer for the person filling it out and helps you determine which fields are needed at each step.

It’s best to start by mapping out your process, then break the form into steps that match how users naturally think through the task.

Only use the form to gather information that should come from outside your organization

Intake forms can get overloaded when teams add extra fields that are only useful later in the process.

This is usually not a good idea.

A better approach is to separate:

• Information that the external submitter can provide reliably
• Information that should be derived or normalized later
• Information that belongs only to internal review

Studio’s form model works well here because the form is just the starting point, not the whole process. Claris also notes that after users submit their responses, you can view the data directly in the form view. This makes the form a helpful first step in a larger workflow. Example: client onboarding questionnaire.

Client onboarding is a good example, as it typically includes basic fields, follow-up questions, and internal steps.

A multi-step form for this might look like:

Step 1
Basic contact and company information

Step 2
Project or request type, timeline, and priorities

Step 3
Supporting operational details, systems in use, or business constraints

Step 4
Confirmation, expectations, and submission

This setup makes it easier for users to complete and gives your team better, more organized data.

Build each step to focus on one type of decision

A helpful rule is to ensure each page answers only one type of question.

For example:

• Who is submitting?
• What are they asking for?
• What context do we need?
• Are they ready to submit?

This keeps the form clear and makes it less likely that users will give up partway through.

If a page tries to cover identification, process details, legal review, and internal notes all at once, it’s too much for users.

Look beyond just the form

To build a good Studio intake process, decide what happens immediately after someone submits the form.

That usually means planning for:

• internal review
• routing by request type
• status tracking
• follow-up questions
• assignment or triage

This is important because the form is just the first step in the intake process. Studio is built to let you see the same data in different ways, not just through forms. That means submissions can go straight into a spreadsheet, a list, or another view for your team to handle. End-to-end pattern:

A simple pattern looks like this:

External user

   ↓

Studio multi-step form

   ↓

Submitted intake record

   ↓

Internal Studio view or connected FileMaker workflow

   ↓

Review, routing, assignment, follow-up

This approach is especially helpful when you need submissions to move quickly into a queue or review area.

Decide early on if your workflow should be Studio-first or FileMaker-first

This is one of the key decisions in your setup.

A Studio-first setup means the form creates the first record in Studio, and later steps use or connect to that record.

A FileMaker-first approach treats the intake as the start of a FileMaker-managed workflow, with FileMaker as the main source of truth and logic.

If your intake process changes important records, FileMaker-first is usually safer. If it’s mostly for quick capture and review, Studio-first might be enough.

The best choice depends on how important the data is to your business.

Use the next internal view to make handoffs smoother

A helpful Studio pattern is to connect the form directly to the next internal workspace.

For example:

• The external user submits through a form
• The internal team reviews through a spreadsheet or a list-detail view
• Managers track throughput through a dashboard or hub

This is better than having the form just send results to an email inbox or a static file. Claris designs Studio for multiple ways to view the same data, which is why this approach works well. When multi-step intake works best:

This pattern is especially useful for:

• Vendor onboarding
• Client intake
• Service request submission
• Project request intake
• Event registration with additional context
• Field or inspection data collection

In all these cases, the person submitting needs guidance, the team needs organized data, and the workflow benefits from a queue or follow-up step.

A new way to think about Studio forms

It’s more helpful to see it as more than just “Claris Studio lets us make a web form.”

Instead, think of it as “Claris Studio lets us design the first stage of a structured intake workflow.”

This shift is important because it encourages you to plan for each stage, what happens next, and how your team will use the data, not just the submission page. That’s what makes a multi-step intake process truly useful.

Custom views turn Claris Studio into a true design tool.

Prebuilt views in Claris Studio are helpful, but custom views make the platform much more engaging for technical teams.

Claris says custom views give you “absolute control over form and function.” You can combine fields, data controls, summary objects, and static objects to create purpose-built workspaces rather than generic record displays. Some processes do not fit neatly into a spreadsheet, kanban board, or list-detail view. Sometimes, you need a focused workspace that brings different types of information together in one place.

Begin by focusing on a single process, not just a screen.

The best custom views start with a specific process question.

For example:

• How should an approver review and act on incoming requests?
• How should a dispatcher assign work across a team?
• How should a manager monitor and resolve exceptions?
• How should a reviewer compare summary metrics with the underlying records?

These are workspaces designed for specific processes, not just “custom layouts.”

This distinction is important because it changes your design approach. The goal is not to display everything, but to help one role do one job well.

Know the hierarchy before you start building.

Claris highlights data inheritance as a key concept for custom views. There are three main data layers: view, subview, and frame. A view can have up to three frames, and each frame can show one subview at a time. It helps to think hierarchically from the beginning.

The view acts as the main workspace.
Subviews define focused record areas within the workspace.
Frames let you place and organize those areas within a single layout.

This is why custom views feel more like designing a workspace than just building a layout.

Use frames to group related information, not to add unrelated clutter.

Frames are only available in custom views. Claris describes them as a way to display data and content from multiple tables in a single view, but this can also make it easy to add too much.

A good custom view usually includes only the information needed for the process. For example, an approval workspace might have:

• A card list or spreadsheet of pending items
• A detail panel showing the selected record
• Summary metrics across the queue

This is a strong use of frames because all three areas support the same task. It is not effective to keep adding panels just because you can.

Rely on data controls for the main workflow.

Claris offers several data controls for custom views, such as card lists and spreadsheets. A card list can display records as cards, allow filtering and sorting, and update other objects in the view when a record is selected. A spreadsheet object can show records as rows and columns. With these controls, custom views become practical. A card list can serve as the navigation area, the selected record can drive the rest of the view, summary objects can show workload or status, and static objects can provide labels, grouping, or instructions.

This creates a pattern like this:

Frame 1: queue or record list

Frame 2: selected record detail

Frame 3: summaries, actions, or supporting context

This approach is much better than trying to copy a full FileMaker layout field by field.

A good example is building an approval workspace.

Imagine a capital request approval process.

An approver does not need the whole database. They need:

• a list of requests waiting for review
• the currently selected request
• key fields, supporting notes, and attachments
• summary context, such as total pending by department or aging by status

A custom view works well here because you can set up a queue on one side, a focused detail area in another frame, and summary objects above or next to it.

This gives the user a real workspace, not just a record browser.

Use custom views when prebuilt view types are not enough.

Prebuilt views are usually the right starting point.

Choose a custom view when you need to combine different behaviors, not just change the appearance. This includes situations where you want:

• A queue plus a detail panel on one screen
• Summary metrics tied to the currently selected workflow
• Multiple tables represented in one work surface
• A highly specific operational console for one role

Claris’s documentation makes it clear that custom views are designed for this level of control, especially when you need to combine different types of objects in one interface.

Custom views are powerful, but they should not be the place to create your core process rules.

The same discipline still applies here:

• Validation logic belongs in the source system
• Status rules belong in the source system
• Cross-record side effects belong in the source system
• Audit-sensitive actions belong in the source system

The custom view should offer a better interface for a role, not act as a hidden rules engine.

This is especially important when the underlying data comes from FileMaker.

A clear build sequence usually looks like this:

1. Define the role and the process.
2. List the decisions the user needs to make.
3. Identify the records and summary data needed for those decisions.
4. Decide which parts belong in queue, detail, and summary areas.
5. Use frames and subviews to support that flow.
6. Keep your first version focused and simple.

This last point is important. Custom views are flexible, so it is easy to try to build too much at once.

When to use custom views

Custom views are strongest when:

• One role needs a purpose-built workspace
• The process benefits from combining queue, detail, and summary
• The built-in view types are close, but not enough
• You want to expose a cleaner operational experience than a broad default interface

They are less compelling when:

• A spreadsheet, list-detail, or kanban view already solves the problem
• The team has not defined the workflow clearly
• The workspace would become a dumping ground for unrelated information
  
  

A better way for technical teams to think about custom views

The most helpful way to think about a custom view is not as just “a prettier layout.”

Instead, it is a process-specific workspace with a clear information hierarchy.

This way of thinking leads to better design choices, clearer layouts, and a higher chance that the view will help someone work more efficiently.