Bubble Docs
  • Introduction
  • New? Start Here
  • What is Bubble?
  • The Glossary
  • User manual
    • Getting started
      • What is Bubble?
      • Building for...
        • Web
        • Native iOS and Android
          • Mobile app quick start guide
          • What is a native mobile app?
          • Native mobile vs. web development
          • Differences in native and web elements
          • Native mobile app terminology
      • Building your first app
        • Planning features
        • Database structure
        • Design and UX
        • eCommerce and payments
          • Shopping cart
          • Checkout page
          • One-time payments
          • Subscriptions
          • Marketplace
      • Creating and managing apps
      • The Bubble editor
        • Tabs and sections
          • Design tab
            • The element tree
            • The property editor
          • Workflow tab
          • Data tab
          • Styles tab
          • Plugins tab
          • Settings tab
            • Application settings
              • Custom headers/body
              • Visual settings
              • Social media sharing
              • Translating your app
              • Email settings
              • Collaboration
            • Custom domain and DNS
          • Logs tab
        • Tools
          • Key features
          • The search tool
          • The Issue Checker
          • The element tree
          • The element property editor
          • The debugger
          • Notes
        • Previewing your app
      • Transitioning to Bubble from...
        • JavaScript
        • HTML and CSS
        • SQL
    • Design
      • Elements
        • Web app
          • The page
          • Containers
            • Groups
            • Repeating groups
            • Table elements
            • Popups
            • Floating groups
            • Group focus
          • Visual elements
          • Input forms
            • Text and numbers
            • Dates and time
            • File uploads
            • Selection controls
        • iOS and Android app
          • The view
          • Containers
          • Visual elements
          • Input forms
          • Mobile reusable elements
        • The element hierarchy
          • The element tree
        • Reusable Elements
      • Styling
        • Color variables
        • Font variables
        • Styles
        • Custom Fonts
      • Responsive design
        • Building responsive pages
        • Legacy articles
          • The Basics (Legacy)
          • Building Responsive Pages (Legacy)
          • Migrating Legacy Pages
          • Tips When Designing (Legacy)
      • Templates
      • The Component Library
      • Importing from Figma
    • Data
      • The database
        • Data types and fields
        • Creating, saving and deleting data
        • Finding data
        • Displaying data
        • Protecting data with privacy rules
        • The database editor
        • Export/import data
          • Exporting data
          • Importing data (CSV)
        • Working with location data
        • Using Algolia
        • Database structure by app type
          • Marketplace Apps
          • Directory & Listings Apps
          • Social Network Apps
          • SaaS Apps
          • Project Management Apps
          • CRM Apps
          • Professional Services Apps
          • On-demand Apps
          • Documentation/ CMS Apps
          • Applicant Tracking System (ATS) Apps
          • Portfolio Apps
          • Gallery Apps
          • Online Store / Ecommerce Apps
          • Blog Apps
          • Messaging App
          • Dashboards
          • Building Block Apps
          • Bubble as a backend
      • Files
      • Images
      • Static data
        • App texts (translations)
        • Option sets
      • Temporary data
        • Custom states
        • URL parameters
      • User accounts
        • Authentication plugins
          • Facebook plugin
          • Fitbit plugin
          • Google plugin
          • Instagram plugin
          • LinkedIn plugin
          • Pinterest plugin
          • Slack plugin
          • Wistia plugin
          • YouTube plugin
        • Cookies set by Bubble
      • Time, dates and time zones
    • Logic
      • The frontend and backend
      • Workflows
        • Events
          • Frontend events
            • Recurring workflows
            • Custom events
          • Backend events
            • Database trigger events
        • Actions
        • API Workflows
      • Dynamic expressions
      • Conditions
      • Navigation
        • Single-page applications (SPA)
        • Multi-page applications
        • Page slugs
      • Device resources
        • Location services
        • Camera/photo library
    • Workload
      • Understanding workload
        • Activity types
        • The workload calculation
        • Client-side and server-side processing
      • Tracking workload
        • Measuring
          • Using App Metrics
        • Monitoring
          • Workload notifications
          • Infinite recursion protection
      • Optimizing workload
        • Optimization framework
        • Optimization checklist
          • Page load
          • Searches
          • Workflows and actions
          • Backend workflows
        • Agency showcases
          • Minimum Studio
          • Neam
          • Support Dept
    • Security
      • Bubble's security features
      • Planning app security
      • Client-side and server-side
      • Bubble account security
      • App security
      • Page security
      • Database security
      • API security
        • API Connector security
        • Data API security
        • Workflow API security
      • Flusk
        • Overview
        • Flusk plan features
        • Getting started with Flusk
        • Flusk security tools
          • The Issues Explorer
          • Issue details
          • Tools and settings
            • Pages rating
            • Database rating
        • Flusk FAQ
      • Cookies
      • Security checklist
    • Previewing your app
      • Previewing a web app
      • Previewing a mobile app
    • Publishing your app
      • Web app
      • Native mobile app
        • Global native mobile settings
        • iOS App Store
        • Google Play Store
        • Publishing FAQ
    • AI
      • Generate apps with AI
        • About AI app generation
      • AI page designer
      • Connect to AI agents
    • Maintenance
      • Collaborators
      • Version control
        • Best practices: Version control
        • Transitioning from the legacy version control
        • Terminology: Version control
        • Version Control (legacy)
      • Commenting
      • Database maintenance
        • Copying the database
        • Restoring database backups
        • Bulk operations
          • Bulk operation methods compared
        • Wiping change history
      • Performance
        • Hard limits
        • Capacity Usage (legacy)
        • Notes on queries
      • SEO
        • Introduction to SEO
        • SEO: App
        • SEO: Page
      • Testing and debugging
        • Introduction to testing and debugging
        • The debugger
        • The native mobile debugger
        • The server logs
        • Supported browsers
      • API workflow scheduler
    • Integrations
      • API
        • Introduction to APIs
          • What is a RESTful API?
        • The Bubble API
          • Bubble API terminology
          • Authentication
            • How to authenticate
            • No authentication
            • As a User
            • As an admin
          • The Data API
            • Data API Privacy Rules
            • Data API endpoints
            • Data API requests
          • The Workflow API
            • Workflow API privacy rules
            • Workflow API endpoints
            • API workflows
              • Creating API workflows
              • Scheduling API workflows
              • Recursive API workflows
              • API Workflow Scheduler
              • Case: Stripe notifications
        • The API Connector
          • Authentication
          • API Connector security
          • API guides
            • OpenAI
              • Authentication
              • Calls
                • ChatGPT
                  • Chat
            • Google Translate
              • How to setup Google API keys
          • Streaming API
        • API security
        • Plugins that connect to APIs
        • API Glossary
      • Plugins
        • What Plugins Can Do
        • Installing and using Plugins
        • Authentication plugins
        • Special Plugins
      • SQL Database Connector
      • Bubble App Connector
      • WorkOS
        • WorkOS SSO
        • WorkOS API
    • Infrastructure
      • Sub-apps
      • Bubble release tiers
      • Hosting and scaling
        • How Bubble hosting works
        • Scaling with Bubble
        • CDN (Cloudflare)
        • Bubble app names
        • Domain and DNS
      • Compliance
        • GDPR
        • SOC 2 Type II
        • HIPAA
        • Other frameworks and standards
    • Bubble for Enterprise
      • Hosting and infrastructure
        • Dedicated instance
          • The Dedicated editor experience
          • Technical specs
          • Main cluster dependencies
          • Customizable options
          • Migration process
            • Pre-migration
            • During migration
            • Post-migration
      • Security and compliance
        • Single sign-on (SSO)
        • GDPR
        • SOC 2 Type II
        • HIPAA
        • Other frameworks
        • Bubble's security features
      • Admin and collaboration
      • Priority support
      • Billing and Payment Guideline for Dedicated Instances
  • Core Reference
    • Using the core reference
    • Bubble's Interface
      • Design tab
      • Design tab (Legacy)
      • Workflow tab
      • Data tab
      • Styles tab
      • Styles tab (Legacy)
      • Plugins tab
      • Settings tab
      • Logs tab
      • Template tab
      • Toolbar
      • Top and context menu options
      • Deployment and version control
        • Deployment & Version Control Dropdown (legacy)
      • Notes
    • Elements
      • Native mobile elements
        • View element
        • List component
      • General properties
      • General properties (Legacy)
      • Styling properties
      • Styling Properties (Legacy)
      • Responsive Properties
      • Responsive Properties (Legacy)
      • Conditional formatting
      • States
      • Page Element
        • Page Element (Legacy)
      • Visual Elements
      • Containers
      • Container Layout Types
      • Containers (Legacy)
      • Input Forms
      • Reusable Elements
      • Element Templates (legacy)
    • Workflows
    • Events
      • General events
      • Element events
      • Custom events
      • Recurring event
      • Database trigger event
    • Actions
      • Account
      • Navigation
      • Data (things)
      • Email
      • Element
      • Custom
    • On-device resources
    • Data
      • Data Sources
      • Operators and comparisons
      • Search
      • Privacy
    • Styles
    • API
      • The Bubble API
        • The Data API
          • Authentication
          • Data API endpoints
          • Data API requests
        • The Workflow API
      • The API Connector
        • Authentication
        • Adding calls
    • Bubble-made Plugins
      • AddtoAny Share Buttons
      • Airtable
      • API Connector
      • Blockspring
      • Box
      • Braintree
      • Bubble App Connector
      • Chart.js
      • Circle Music Player
      • Draggable Elements
      • Dropzone
      • Facebook
      • Fitbit
      • Full Calendar
      • Google
      • Google Analytics
      • Google Optimize
      • Google Places
      • Ionic Elements
      • iTunes
      • Slidebar Menu
      • LinkedIn
      • Localize Translation
      • Mixpanel
      • Mouse & Keyboard Interactions
      • Multiselect Dropdown
      • Progress Bar
      • Rich Text Editor
      • Rich Text Editor (Legacy)
      • Screenshotlayer
      • SelectPDF
      • Slack
      • Segment
      • Slick Slideshow
      • SQL Database Connector
      • Star Rating
      • Stripe
      • Tinder-like Element
      • Twitter
      • YouTube
      • Zapier
    • Application Settings
      • App plan
      • General
      • Domain / email
      • Languages
      • SEO / metatags
      • API
      • Collaboration
      • Sub-apps
      • Versions
  • Account & Marketplace
    • Account and billing
      • Pricing and plans
        • Plans and billing
        • Billing cycle
        • FAQ: Pricing and Workload
      • Account Management
      • Building Apps for Others
      • Selling on the Marketplace
      • Plans & Billing (legacy)
    • Official Bubble Certification
      • Hiring certified developers
    • Building Plugins
      • The Plugin Editor
      • General Settings
      • Updating to Plugin API v4
      • Adding API Connections
      • Building Elements
      • Building Actions
      • Loading Data
      • Publishing and versioning
      • Github Integration
    • Building Templates
    • Application and data ownership
    • Marketplace policies
    • Bug reports
  • Vulnerability Disclosure Policy
  • Beta features
    • About the Beta features section
    • Native mobile apps
Powered by GitBook
On this page

Was this helpful?

Last updated 2 months ago

Was this helpful?

Before you start building, you need to decide what kind of features your app needs. Most app ideas start out as a general vision of what the app is supposed to do. You then take that vision and breaks it into the features needed to make that happen. When you've decided on the features you need, you can start planning how those features should work in an actual interface.

In this article, we'll cover:

What is a feature?

A feature is essentially a distinct function or capability that an app offers. It's what allows users to perform certain tasks or achieve specific outcomes within an app. They can broadly be categorized into two types: general features and specific features.

General features

These are foundational features commonly found in a majority of apps across different genres. They form the basic infrastructure, facilitating the core user interactions.

Typical examples include:

  • User sign-up/sign-in: allow users to create an account and log into the app

  • Reset password: let users reset their password without you as the developer having to intervene

  • Notifications: alert users about updates, messages, or other important information

  • Search bar: let users search for content

General features are what makes your app work, but they're not what sets it apart. When you plan your app, it's a good idea to list these features as well, to make sure you have the full picture of the project ahead.

Specific features

Specific features are unique to the nature and purpose of the app. They are linked closely with the app's core idea. For instance:

  • For a food delivery app, a specific feature might be the ability for users to explore a restaurant's menu and add items to a cart

  • In a language learning app, a custom vocabulary quiz tailored to a user's learning history could be a specific feature.

  • For a budgeting app, a feature that projects future savings based on current spending habits might be included.

The specific features are what sets your app apart from other apps: the reason it's being developed in the first place. If your app exists to solve a problem, the app's features are how the problem will be solved.

Next, let's look at how you can prioritize features by thinking of your app in versions.

Think in versions

It's useful to think of your app in versions, so that you know what exactly you are building. It's very easy to come up with new ideas as you work, and get sidetracked from your initial plan.

By planning out versions, you can stay focused on delivering a core set of features first, and then progressively enhance and expand your app based on feedback and actual user needs.

For example, you could think about your versions as follows:

1. MVP (Minimum Viable Product): This is the most basic version of your app, with only the essential features needed to make it functional. The goal here is to get something to market quickly to test the concept, gather feedback, and identify potential improvements and even .

2. Version 1.0: Once you've validated the idea with your MVP, it's time to refine. This version will have improved UX/UI, and possibly some new features based on the feedback from your MVP. You'll also address any significant bugs or problems identified during the MVP phase.

3. Version 2.0 (and beyond): As your user base grows and you collect more feedback, you'll start to identify more areas for enhancement and expansion. This could involve adding new features, improving existing ones, or expanding into new markets or platforms.

Remember, it's tempting to want to add every feature you can think of from the get-go, but restraint can help you get your app to the market on schedule. Every time a good idea comes up, you can of course take note of it, and plan it into a future version.

Furthermore, taking a step-by-step approach allows you to adapt and pivot based on real-world feedback, rather than assumptions.

Users will often use your app in ways you hadn't anticipated or express needs you hadn't considered. By listening to them and iterating on your product, you increase the chances of your app's success in the long run.

Planning features for your MVP

The first version of an app is often referred to as the Minimum Viable Product (MVP). The goal is to create something functional that effectively addresses the primary need or problem you've identified, without getting bogged down in secondary features or details.

Here's how you can approach this:

  1. Identify the core problem: What primary problem does your app aim to solve? Understanding this will help you prioritize the features that are absolutely necessary for your MVP.

  2. User stories: Draft user stories to envision how users will interact with your app. For example: "As a user, I want to be able to create new contacts so that I can keep track of my clients."

  3. Prioritize features: List all the features you envision for your app and then rank them based on their importance to the core problem. Focus on the top priorities for your MVP.

  4. Sketch or wireframe: Use sketches or wireframes to map out the user journey and interface. This visual aid will help you understand how the features integrate and flow together.

  5. Feedback loop: Share your prioritized feature list and wireframes with potential users, stakeholders, or teammates. Gather feedback and adjust your plan accordingly.

  6. Avoid : It's tempting to add more features as you plan, but stay focused on the primary goal. Additional features can always be added in later versions once the MVP has been tested and validated.

  7. Plan for feedback collection: As the purpose of the MVP is to test and validate your idea, have mechanisms in place (like feedback forms, analytics tools, etc.) to gather user feedback once it's launched.

Even if Bubble is a very efficient tool to build in, don't be afraid to leave out features that are not absolutely needed to get your idea validated. You can always add those in later.

The user journey

A user journey represents the series of steps or interactions a user undertakes to achieve a particular goal within your app or website. By mapping out these journeys, you can make sure that you have a plan for how users will reach a specific goal step-by-step.

When designing user journeys, start by envisioning a specific persona. Who is the individual embarking on this journey? Understanding this user's characteristics can guide you in tailoring the experience to suit their needs. For instance, while some users might be tech-savvy, others could benefit from more detailed instructions and a prominent .

Sign-up user journey

For example, you could set up a user journey for signing up to your app. This process can be a critical, as it often represents a user's first interaction with your app.

  1. User persona:

    • Name: Sarah

    • Age: 28

    • Tech-savviness: Moderate

    • Goal: To sign up for the app quickly and without hassles to explore its features.

  2. Entry point:

    Sarah hears about the app in social media and decides to try it out

  3. Opening the app:

    Sarah opens the app and is greeted with a welcome screen showcasing the app's main features.

  4. Call to action:

    After the intro slides, Sarah sees two prominent buttons: "Sign Up" and "Log In."

  5. Sign up option:

    Sarah clicks on "Sign Up" and is presented with options:

    • ","

    • ","

    • "."

  6. Choosing sign-up method:

    Wanting to keep things simple, Sarah chooses "Sign Up with Google."

  7. Permissions:

    A prompt asks Sarah to allow the app to access her Google account info. She confirms.

  8. Additional details:

    The app asks Sarah for a few more details to enhance her experience: her interests and preferences related to the app's features.

  9. Confirmation and feedback:

    Once she provides the details, Sarah gets a success message: "Thank you for signing up, Sarah! Let's get started."

  10. Profile setup (optional step): Sarah is then prompted to complete her profile by adding a profile picture and other optional details.

  11. First use experience: After the onboarding, Sarah is directed to the app's main dashboard or home screen to start exploring.

  12. Follow-up email: Five minutes later, Sarah receives a welcome email reiterating the app's features and providing resources like FAQ and customer support links.

Throughout this journey, keep the following things in mind:

  • Ensure that each step is intuitive and not overwhelming.

  • Provide clear instructions and feedback.

  • If needed, make it easy to ask for help.

  • Keep the number of steps minimal, asking only for necessary information to ensure a high signup rate

While many sign-up processes look very similar, you don't need to see this as a blueprint: you are free to add or remove steps that you think make sense for your app. The idea is to know what the process should look like before you start building. This approach ensures you don't overlook crucial steps, making your development process as efficient as possible.

Technical feasibility: If you are unsure whether Bubble is the right platform for your project, you can get in touch with our or ask other users in our active . Describe your idea and you can quickly get feedback on whether it's feasible.

You can set up the user journey in steps, like we did in the example, but you can also use apps like , or to set it up more visually. Sometimes, good old pen and paper works best.

In the next section, we'll explore how you can think about the .

  1. User manual
  2. Getting started
  3. Building your first app

Planning features

What a features is
How to plan what features you want to include in the first version of your app
Setting up user journeys to decide how a specific feature should work
Success team
forum
Miro
Apple Freeform
Lucid
data that you want to manage in your app
  • What is a feature?
  • General features
  • Specific features
  • Think in versions
  • Planning features for your MVP
  • The user journey
  • Sign-up user journey