Maxbot is a visual chatbot builder that helps you design interactive conversation flows without hardcoding the entire experience. It is built for guided chat journeys such as lead capture, support routing, FAQs, onboarding, bookings, recommendation flows, and documentation assistance.

At the center of the product is the Flow Editor, where each block represents one step in the conversation. You define what the bot says, how the user can answer, what should be saved, and how the conversation should continue.

Maxbot is not only a message editor. It is a conversation design system that combines flow branching, structured data capture, guided replies, keyword routing, rich content, testing, and iterative improvement.

Before building your first chatbot, it helps to understand the terms used across Maxbot.

Agent
An agent is the chatbot identity shown to users. It usually includes a name, avatar, occupation, and short description.

Topic
A topic is a conversation flow. Each topic contains its own logic and structure inside the Flow Editor.

Block
A block is one conversation unit. It can send one or more bot messages, wait for input, display media, save user data, or redirect the flow.

Data Entity
A data entity is a reusable field used to capture structured user information such as name, email, phone, company, city, or any custom value.

Variable
A variable is the identifier used to reuse a saved value later in the conversation, such as @name or @email.

Training
Training is the process of reviewing unmatched user replies so you can improve coverage, routing, and clarity over time.

A clean Maxbot project usually follows a simple sequence:

1. Create the agent.
2. Create the topic.
3. Define data entities if you want to collect user information.
4. Build the conversation in the Flow Editor.
5. Test the flow using the built-in widget preview.
6. Review captured user data.
7. Inspect unmatched replies and improve the flow.

This order keeps the project structured and helps you avoid rebuilding flow logic later because of missing fields or unclear objectives.

The agent is the visible identity of the chatbot. It gives personality to the experience and helps users understand what the bot is there to do.

A typical agent includes a display name, an avatar image, an occupation or role, and a short first-person description.

Strong agent examples include roles such as Sales Assistant, Customer Support Agent, Product Guide, Booking Assistant, or Documentation Helper.

A good description should explain the bot’s job clearly. For example: I help visitors find the right service, answer common questions, and guide them to the next step.

A topic is where a chatbot journey starts. Each topic contains one conversation structure and should represent one clear objective.

Examples of strong topic scopes include Contact Us, Pricing Questions, Product Recommendation, Technical Support, Demo Booking, or FAQ Assistant.

When a topic tries to do too many unrelated things, the conversation becomes harder to maintain, harder to test, and harder for users to understand.

Keeping topics focused also makes it easier to reuse logic, create templates, and improve performance over time.

Before opening the Flow Editor, it helps to answer a few product questions:

1. What should the chatbot achieve?
2. What should the user be able to do?
3. What information should be collected?
4. Should the experience be guided, flexible, or hybrid?
5. What are the ideal outcomes of the flow?

For example, a lead generation topic may need name, email, phone, and service interest. A support topic may need issue type, order number, and a free-text description.

Planning this early makes the actual flow design much smoother and reduces later rework.

Templates are prebuilt chatbot structures that help you start faster instead of building every flow from scratch. A template usually includes a conversation idea, a block structure, and starter content that you can adapt to your own project.

Templates are especially useful for first-time users, common chatbot use cases, rapid prototyping, and learning how a strong Maxbot flow is typically designed.

Instead of starting with an empty canvas, you begin with a working base and customize it to match your brand, logic, and business goal.

Templates make Maxbot easier to adopt because they reduce the blank-page problem. They help users launch faster, understand flow structure, discover product capabilities, and reuse proven chatbot patterns.

They are not only shortcuts. They are also educational examples that show what a polished implementation can look like in practice.

When you choose a template, Maxbot gives you a starting structure that you can edit freely. After loading a template, you can usually rename the topic, change the agent identity, update bot messages, adjust quick replies, modify branching, replace media and links, and connect your own data entities.

A template should be treated as a starting point, not a finished chatbot. The goal is to save time while still shaping the flow around your own use case.

Both approaches are valid. Use a template when the use case is common, when you want speed, when you want inspiration, or when you are still learning the product. Build from scratch when the flow is unique, when you want full control from the first step, or when a template would require more rewriting than rebuilding.

The best choice depends on how close the template is to your real business need.

Templates are especially useful for recurring business scenarios such as lead capture, contact requests, support intake, appointment booking, FAQ assistance, service recommendation, e-commerce guidance, real estate inquiry, restaurant reservations, and healthcare appointment flows.

A good template library makes Maxbot feel practical from the first minute because users can see immediate examples of what the platform can do.

A template should never be used blindly. Once it is loaded, adapt it carefully to your brand tone, your actual user journey, and the information you need to collect.

• Rewrite messages so they sound like your brand.
• Replace placeholder content and media.
• Validate the data collection fields you keep.
• Remove blocks that do not serve your use case.
• Test the flow before publishing.

The Flow Editor is the core workspace where chatbot conversations are built. Each block represents one moment in the conversation. By connecting blocks together, you create the chatbot’s structure and behavior.

A block can send one or more bot messages, wait for user input, require quick replies, save answers, display media, route the flow, or surface unmatched replies for training.

The editor gives you a visual way to build both simple and advanced chatbot journeys without losing structure.

A block is one conversation unit. It can introduce a message, collect user input, display content, or decide what should happen next. In practice, a chatbot topic is a tree of connected blocks.

Each block should do one clear job. When a single block tries to do too much, the flow becomes harder to read, harder to test, and harder to maintain.

A modern Maxbot block is organized around clear sections so conversation logic remains understandable. The main tabs are usually:

• User Input
• Bot Responses
• Next Step
• Rich Content
• Training

This structure separates how the block is reached, what the bot sends, what happens next, what media is attached, and how unmatched replies can be reviewed later.

At the bottom of the block, Maxbot provides action buttons for common editing tasks such as zooming, collapsing or expanding a block, adding a child block, or deleting a block.

These controls matter more than they seem. In large flows, collapsing and expanding strategically makes the canvas much easier to manage, while child-block creation keeps branching logic fast to build.

Blocks usually follow a parent-child structure. A parent block introduces a step in the conversation, and child blocks define the possible branches that can come next.

For example, a parent block may ask How can I help you today? and its child blocks may represent Pricing, Support, and Book a Demo.

This structure is what makes decision trees, multi-step forms, menu experiences, and guided support flows possible inside Maxbot.

The User Input tab defines the conditions for reaching the current block. Depending on the flow design, it can include trigger keywords, quick reply text, card-based quick reply content, and priority values.

This area becomes especially important when the parent block allows branching through keyword matching or guided user selections.

Trigger keywords define which words or phrases should route a typed user message to the current block. This is useful when users are allowed to write naturally and Maxbot needs to decide which branch they meant.

For example, a pricing block may use terms such as price, pricing, plans, cost, and subscription.

Strong keyword coverage should reflect how real users speak, not just how internal teams describe the feature.

When a block is meant to be selected through a fixed choice, the quick reply text defines the label shown to the user. Examples include Yes, No, Contact Sales, Learn More, or Book Demo.

Use quick replies when you want a more guided, predictable, and reliable user experience.

Maxbot also supports richer quick replies displayed as cards. Each card can include an image, title, short description, and button text.

This works especially well when users need more context before choosing, such as service categories, product types, pricing plans, support areas, or recommended resources.

Cards are stronger than plain buttons when visual comparison matters.

Priority helps Maxbot resolve ambiguous situations where multiple child blocks may match the same input. A higher priority value means the block should win more often when overlap exists.

This is useful for similar keyword groups, broad intent sets, or intentional routing bias. Use it carefully. If overused, it can make routing harder to reason about.

The Bot Responses tab defines what the chatbot sends when a block is reached. A block can contain one or several messages, giving you control over pacing and clarity.

Instead of one large paragraph, it is often better to split content into smaller conversational bubbles: one welcome, one explanation, and one next-step prompt.

That rhythm feels more natural and easier to read inside a chat interface.

Maxbot allows several bot messages inside the same block. This is useful when you want a short sequence instead of one heavy message.

For example:

• Welcome to Maxbot.
• I can help you with pricing, support, and bookings.
• What would you like to do?

This usually feels cleaner than creating a separate block for each short sentence.

Bot responses can reuse saved values through variables such as @name, @email, or @selected_option.

This makes the conversation feel dynamic and personalized. Variables can come from data entities, saved quick reply selections, or free-text replies stored earlier in the flow.

Personalization is one of the strongest ways to make the chatbot feel helpful rather than static.

The Next Step tab controls what should happen after the current block’s messages are sent. This is one of the most important parts of the Flow Editor because it defines the conversation behavior.

Depending on the block, Maxbot can require a quick reply, save the user’s reply into a data entity, let keywords determine the next child block, redirect to another block, or end the conversation.

This mode forces the user to choose one of the available child options instead of typing freely. Use it when you want a guided experience, reliable branch selection, and lower ambiguity.

It works especially well for menus, surveys, product pickers, support categories, and structured qualification flows.

When quick reply mode is active, Maxbot can also save the selected option into the database. This is useful when you want to analyze choices, personalize later messages, keep records, or export user decisions.

Common variable names for saved selections include selected_plan, issue_type, or preferred_service.

This mode is used when you want the chatbot to collect structured user input such as a name, email, phone number, company, city, budget range, or any other reusable value.

When enabled, the chatbot waits for the user’s response and stores it in the selected data entity. This is what turns Maxbot into a conversational form builder as well as a chatbot builder.

This mode allows the user to type naturally and lets Maxbot determine the next branch through keyword matching. It is useful when the flow should feel more flexible or FAQ-like.

This approach becomes much stronger when paired with thoughtful keyword coverage, a useful fallback message, retry logic, and optional quick reply rescue options.

The fallback message is shown when no keyword match is found. Its job is not only to reject the input but to guide the user back toward supported options.

A weak fallback only says the bot did not understand. A strong fallback explains what the user can ask about next.

The retry limit defines how many times the bot should repeat fallback behavior before switching to a stronger guidance method. This prevents dead loops where the user keeps typing unsupported input forever.

A practical setup is often to try once or twice with the fallback message, then show quick replies to recover the flow.

This message appears above the quick replies when Maxbot decides to guide the user with fixed options after repeated unmatched replies.

It should clearly explain what the user should do next. For example: Please choose one of the following options to continue.

Even in keyword-driven flows, Maxbot can save the raw user reply into the database. This is useful for lead qualification, support intake, analytics, later review, and personalization.

Examples of useful variable names include user_question, company_need, and request_details.

Maxbot allows you to redirect the conversation from the current block to another destination instead of continuing only through direct child blocks. This is useful when you want to merge several branches into one shared continuation, avoid duplication, or route the user to a common next step.

In older wording, this was often described as joining this block to other block cases for the conversation to flow. In practice, it is a redirection mechanism that helps connect separate parts of the chatbot structure.

Typical use cases include reusing a shared contact step, returning the user to a central menu, or merging multiple qualification paths into one downstream branch.

Some blocks should close the conversation cleanly instead of branching further. Ending the conversation is useful when the user has completed the intended action, when the flow naturally stops, or when the chatbot should hand the next action off to a human or external process.

A good ending confirms what happened and leaves the user with a clear sense of completion.

Data entities are the structured fields Maxbot uses to save user information. Examples include full name, email address, phone number, company name, country, budget range, or any custom field needed by your flow.

Each entity has a variable that can later be reused inside bot messages. This makes Maxbot capable of acting like a conversational form builder, not only a chatbot.

Data entities make collected information structured, reusable, exportable, easier to validate, and easier to analyze. Instead of saving everything as generic text, you organize information clearly from the start.

This becomes especially valuable when exporting leads, segmenting answers, reviewing submissions, or handing information to another team.

When collecting user data, validation helps make sure the value entered matches the expected format. Depending on the field, Maxbot can support checks such as email, phone, digits only, letters only, alphanumeric values, or a custom regular expression.

If the value is invalid, the bot can show an error message and ask the user to try again. This improves data quality and reduces bad submissions.

Once a value is captured, it can be reused later in the conversation. Examples include Thanks @name, We’ll contact you at @email, or I saved your preferred plan as @selected_plan.

This makes the conversation feel connected and personalized instead of behaving like isolated prompts.

The Users Data area stores the information collected through the chatbot. Depending on how your flows are configured, it may include data entity values, saved free-text answers, saved quick reply selections, timestamps, and session-related information.

This area is useful for lead follow-up, reviewing form submissions, support processing, analytics, and auditing what users actually submitted.

Maxbot is not limited to plain text. A block can include rich content to make the conversation more visual, more helpful, and more interactive.

Supported types include cards, images and GIFs, embedded YouTube videos, and clickable links. Rich content is especially useful for product discovery, onboarding, support, promotions, help-center experiences, and tutorials.

Cards are ideal for presenting structured visual items such as products, plans, articles, service options, or external resources. Each card can include an image, destination link, title, description, and button text.

Cards are one of Maxbot’s strongest content formats because they combine information and action in a very compact way.

Images and GIFs can be attached to a block to make messages more visual and easier to understand. Maxbot can support properties such as image URL, width, and height depending on the content configuration.

This is especially useful for screenshots, previews, simple tutorials, visual references, and expressive reactions.

YouTube videos can be embedded directly inside a block. This is powerful for onboarding, support walkthroughs, product tours, and tutorial-driven chatbot experiences.

When your chatbot is meant to teach users how to do something, video can reduce friction much faster than long explanations alone.

Links are useful when the chatbot should route the user to docs pages, downloads, support articles, booking pages, or external resources.

This makes Maxbot especially effective as a routing assistant that does not always need to finish everything inside the chat itself.

One of the most important Maxbot features is Test Flow. At the bottom of the Flow Editor, this action opens a modal containing the chat widget so you can simulate the real conversation without leaving the editor.

This matters because building a flow visually is not enough. You also need to experience it from the user side.

When testing a flow, verify the order of bot messages, quick reply display, keyword routing, fallback behavior, variable rendering, rich content output, data flow, and how the flow ends or redirects.

Testing should happen continuously while building, not only after the whole topic is finished.

The Training area helps you improve the chatbot by surfacing replies that failed to match any child block. These unmatched replies show what users actually say, what the bot failed to understand, and where your routing may be too weak.

This is one of the most valuable feedback loops in Maxbot because it reveals real user behavior instead of assumptions.

A good chatbot is improved iteratively. A practical improvement cycle is to review saved data, inspect unmatched replies, identify weak prompts, improve keyword coverage, replace confusing open-text steps with quick replies when needed, add missing branches, and test again.

That is how Maxbot becomes smarter over time rather than remaining a one-time static setup.

Integrations extend Maxbot beyond the core builder. They allow the chatbot to become part of larger workflows by connecting it to external platforms, channels, or tools.

Depending on product stage and enabled features, integrations can support deployment to additional channels, connections with external services, or broader workflow usage around the chatbot experience.

Without integrations, a chatbot stays isolated. With integrations, it can become part of customer support workflows, lead handling processes, omnichannel communication, data pipelines, and external business systems.

This makes Maxbot more scalable and more useful in real business environments.

Maxbot began around the web widget experience, but the product direction naturally opens the door to broader channel support, add-ons, and more connected workflows.

The documentation should therefore present Maxbot both as a builder today and as an extensible platform over time.

Add-ons are modular extensions that expand Maxbot’s base capabilities without overloading the core builder. Instead of forcing every possible feature into the default experience, add-ons allow advanced functionality to be enabled when needed.

Examples of add-on directions can include additional communication channels, richer analytics, premium templates, advanced lead handling, automation features, or AI-powered enhancements.

Even when some integrations are still upcoming, it is useful to document them at a high level so users understand the ecosystem direction. The docs should explain that Maxbot is designed to grow beyond the core widget and that some future features may depend on installed modules or enabled plans.

This sets expectations without overpromising implementation details.

Maxbot can collect names, emails, phone numbers, service interests, budgets, and project details in a conversational format that feels lighter than a traditional form.

A strong lead-generation chatbot usually relies on short messages, clear quick replies, structured data entities, and personalized confirmation messages.

Maxbot is very well suited for FAQ experiences. By combining keyword routing, fallback guidance, quick reply rescue, links, cards, and tutorial videos, the chatbot can act as a front door to your documentation or support content.

A recommendation flow can guide users through choices using quick replies, card-based selections, variable storage, and personalized outcomes. This is useful for helping users choose a package, discover a service, select a template, or identify the right product path.

A support chatbot can classify issue types, collect identifiers, save problem details, route users to resources, and reduce manual back-and-forth.

This works especially well when quick replies are used for category selection and free text is used only where descriptive detail is actually needed.

Maxbot can act as a conversational booking or demo request assistant by collecting fields such as full name, email, phone, preferred time, preferred service, and request details.

This creates a much lighter and more guided experience than a large static form.

Maxbot also fits well as a documentation assistant that helps users navigate guides, understand setup steps, and reach the right resources faster. This works especially well when links, tutorial videos, structured choices, and fallback rescue are combined properly.

Do not overload one topic with too many unrelated goals. A topic should usually represent one main objective so the flow stays easy to build, test, and improve.

Quick replies usually outperform open text when clarity and completion rate matter. Use free text where flexibility is truly needed, but use guided choices where reliability matters most.

Messages should feel conversational. Prefer shorter bubbles, clearer prompts, and one idea at a time instead of long text blocks that feel like mini articles inside the chat.

Fallbacks should guide, not only reject. The user should always understand what they can do next, even when the chatbot did not understand the previous reply.

Not every user reply needs to be stored. Save what matters: business data, qualification data, selected options, and important written answers. This keeps the dataset useful instead of noisy.

Unmatched replies are one of the richest sources of improvement. A chatbot usually becomes smarter through real usage review, not only through the first design pass.

The visual editor is for building. The widget test is for truth. Always validate the real conversation experience frequently while creating the flow.