Common Base44 Issues

You've created custom API endpoints in your Base44 app to expose data or functionality to external systems, mobile apps, or other services, but the endpoints return errors when called. The errors may be 404 (not found), 500 (server error), or authentication failures.

Custom API endpoints enable Base44 apps to communicate with other systems and are essential for building more complex integrations. When they fail, any external system depending on your Base44 app's API stops working.

The issue may be specific to certain HTTP methods (GET works but POST doesn't), certain endpoints, or certain callers (works from Postman but not from the external system).

You've integrated Stripe for payment processing in your Base44 app, but payments are failing. The checkout flow may show errors, payments may process in test mode but not live mode, or successful payments may not be reflected back in your app's database.

Payment integration failures are among the most critical issues because they directly impact revenue. Users who experience payment errors may abandon their purchase and not return.

Common symptoms include the Stripe checkout page not loading, payments showing as successful in Stripe's dashboard but not updating the order status in your app, or the entire checkout button doing nothing when clicked.

Your Base44 app's email functionality is not working. Automated emails from workflows (like welcome emails, order confirmations, or notification emails) are not being sent, or they're being sent with incorrect content, broken formatting, or missing dynamic data.

Email is often a critical communication channel for apps. Users expect to receive confirmation emails immediately after actions like signing up, placing an order, or submitting a request. Silent email failures create a poor user experience and can cause business issues.

The problem may be selective: emails to some domains (like Gmail) work fine but emails to corporate domains fail, or emails send but dynamic template variables show as blank or literal placeholder text.

You've set up a webhook endpoint in your Base44 app to receive data from an external service (such as payment notifications from Stripe, form submissions from another platform, or updates from a CRM), but the webhook data never arrives or is not processed correctly.

Webhooks are crucial for real-time integrations. When they fail, your app misses important events like payment confirmations, status updates, or new lead notifications, potentially causing business-critical failures.

The failure may be silent: the external service reports successful delivery but your Base44 app shows no record of receiving the data.

You've configured a third-party API integration in your Base44 app (such as connecting to Stripe, SendGrid, Airtable, or a custom REST API), but the integration fails. Requests return errors, data doesn't sync, or the connection times out.

API integrations are critical for extending Base44 apps with external services. A broken integration can prevent payment processing, email sending, data synchronization, or any other external functionality your app depends on.

The issue may manifest differently: some API calls succeed while others fail, or the integration works from the editor but fails in the published app.

You've set up workflow automations in your Base44 app (such as sending an email when a form is submitted, updating a record when a status changes, or creating a related record automatically), but the workflows never fire or only fire intermittently.

Automations are a key feature of Base44 for building business logic without code. When they don't trigger, manual intervention is needed for every action, defeating the purpose of the automation.

The issue can be hard to debug because there's no visible error; the automation simply doesn't execute, and you only discover it when you notice the expected outcome didn't happen.

Your Base44 app needs to generate PDFs (invoices, reports, certificates, etc.), but the generation process fails, produces blank documents, or creates PDFs with missing or incorrectly formatted data.

PDF generation is critical for business apps that need to provide professional documents to customers. Failed invoice generation, for example, directly impacts billing and cash flow.

The issue may be intermittent: some PDFs generate correctly while others fail, often depending on the data content. Records with special characters, very long text, or many related items tend to cause the most problems.

Your Zapier or Make (Integromat) integration with Base44 has stopped working. The automation that was previously syncing data between Base44 and other apps is no longer triggering, or the connection shows as disconnected in the Zapier/Make dashboard.

Integration platforms like Zapier are often the glue between Base44 apps and the rest of a business's tool stack. When these connections break, data stops flowing, notifications stop sending, and manual workarounds are needed.

The disconnection may have happened silently, and you only discover it when you notice data isn't being synced or actions aren't being performed.

You have enabled Google login (or another social OAuth provider) in your Base44 app, but clicking the social login button results in an error. Users may see a Google error page, a "redirect_uri_mismatch" message, or get redirected back to the login page without being authenticated.

This issue is particularly frustrating because social login often works perfectly in the Base44 editor preview but breaks in the published version of the app. The OAuth flow requires precise URL matching that can easily go wrong between environments.

Users of your Base44 application are being logged out unexpectedly and frequently. They may be in the middle of filling out a form or performing an action when the session expires, losing their unsaved work and causing frustration.

This issue is especially problematic for apps where users need extended working sessions, such as data entry applications, admin dashboards, or project management tools built with Base44.

In some cases, the session seems to expire after a fixed short period regardless of user activity. In other cases, it only expires when the user switches tabs or leaves the app idle for even a brief period.

You have configured roles in your Base44 application (such as Admin, Editor, Viewer) but users are still able to access pages and perform actions that should be restricted to specific roles. The role-based access control appears to have no effect.

This is a critical security issue, especially for apps handling sensitive data. You may notice that regular users can access admin dashboards, edit records they should only be able to view, or see navigation items that should be hidden from their role.

The problem can be inconsistent: sometimes access is properly blocked on one page but not on another, or it works in the editor preview but fails in the published app.

Users sign up for your Base44 application but never receive the verification email. Some users report that the email arrives but the verification link doesn't work, redirecting to an error page or an expired token message.

This breaks the entire onboarding flow. Users are unable to confirm their accounts and may be locked out of the application entirely. In some cases the email lands in spam folders, but in others it is never sent at all.

The issue may appear intermittently, working fine for some users but failing for others, particularly those with certain email providers like Outlook or corporate email systems.

After setting up user authentication in your Base44 app, the login page fails to load or displays a completely blank white screen. Users cannot access any protected pages and the entire authentication flow appears broken.

This issue frequently occurs right after enabling the built-in auth module or after making changes to page visibility settings. The browser console may show JavaScript errors related to the auth component failing to initialize.

In some cases the page partially loads but the login form fields never appear, leaving users stuck with no way to sign in to your application.

You've used up your Base44 AI generation credits. Your app is partially built but there are features missing, bugs to fix, or integrations that need work. Each AI generation in Base44 costs credits, and complex app functionality can burn through them quickly.

Base44 is great for building initial app structure and basic CRUD operations, but more complex features like custom logic, third-party integrations, and advanced UI often require many generation attempts.

Before buying more credits, consider whether the AI approach is the most efficient path to a finished app.

When users try to save or update records in your Base44 application, they encounter validation errors that don't make sense based on the data they've entered. The error messages may be vague or technical, leaving users confused about what they need to fix.

Validation errors can appear on forms where the user has filled in all visible fields correctly. The problem is often caused by hidden fields, auto-generated fields, or type mismatches between what the form submits and what the database column expects.

In some cases, records that were previously savable suddenly start throwing validation errors after a schema change, even though the data appears identical.

Users fill out and submit a form in your Base44 app, but the data never appears in the connected database table. The form may appear to submit successfully (no error shown to the user), but when you check the data table, the records are missing.

This is one of the most common and frustrating issues in Base44 apps because it silently loses user data. The form submission may show a success message, but the data is quietly dropped somewhere in the pipeline between the form component and the database.

In some variations, partial data saves (some fields are stored, others are blank) or the data saves to the wrong table entirely.

Your Base44 app uses related database tables (for example, a Users table linked to an Orders table), but the relationships are not working correctly. Related records don't appear in linked views, creating a record in one table doesn't properly reference the related record in another, or deleting a record causes unexpected cascade effects.

This issue often manifests as dropdown selectors for related records showing empty lists, detail pages failing to display linked data, or errors when trying to create records that reference other tables.

Relationship issues can be subtle and may only appear with certain data combinations or when the related tables grow beyond a small number of records.

You are trying to import existing data into your Base44 app via CSV upload or data migration, but the import fails partway through or produces corrupted data. Some rows may import successfully while others are skipped or contain garbled values.

This is a critical issue when migrating from another platform to Base44 or when bulk-loading data for an existing business process. Partial imports are especially dangerous because they leave the database in an inconsistent state.

Common symptoms include columns being shifted (data appearing in the wrong fields), special characters being corrupted, date formats being misinterpreted, and the import timing out for large files.

Your Base44 application is creating duplicate records in the database. Users submit a form once but two or more identical records appear in the table. This can also happen through automated workflows or API integrations that fire multiple times.

Duplicate data causes serious problems: incorrect counts in dashboards, duplicate email notifications being sent, billing errors, and general data integrity issues that compound over time.

The duplicates may be exact copies or near-duplicates where most fields match but timestamps or auto-generated IDs differ slightly, indicating the same action was triggered multiple times in quick succession.

Computed or formula fields in your Base44 database tables are showing stale, incorrect, or blank values. When you update the source fields that the formula depends on, the computed field does not recalculate automatically.

This issue is especially problematic for apps that rely on calculated totals, status indicators, or derived values. For example, an order total field that sums line items may show zero, or a status field based on a date comparison may not reflect the current date.

In some cases, the computed field works correctly for newly created records but fails to update when the underlying data changes.

Your published Base44 app shows SSL certificate warnings in the browser. Users see "Not Secure" in the address bar, a certificate error page they must click through, or mixed content warnings where some resources load over HTTP instead of HTTPS.

SSL issues erode user trust and can prevent some browsers from loading the app at all. Modern browsers increasingly block mixed content and show prominent warnings for certificate issues, making this a critical problem for any production app.

The issue may affect only your custom domain while the default Base44 URL works fine with SSL, or it may manifest as intermittent certificate errors that come and go.

You've configured a custom domain for your Base44 app, but visiting the domain shows an error page, a default hosting page, or the connection times out entirely. The app continues to work on the default Base44 URL but not on your custom domain.

Custom domain configuration involves DNS settings that must be precisely correct, and errors in this process are common. The issue may be compounded by DNS propagation delays that make it hard to tell if your changes have taken effect.

Some users experience a partially working state: the domain loads but shows SSL certificate warnings, or it works without www but not with www (or vice versa).

Your Base44 app works perfectly in the editor and preview mode, but after publishing it to a live URL, the app doesn't load. Users see a blank page, a loading spinner that never resolves, or an error message.

This is a common and stressful issue because the app appeared to be fully functional during development. The disconnect between the editor environment and the published environment can be caused by several factors related to how Base44 builds and deploys apps.

In some cases, the app partially loads (the layout appears but data doesn't populate), or certain pages work while others don't.

Your Base44 app uses environment variables or secret keys (for API integrations, database connections, or third-party services), but these values are not available in the published version of the app. Features that depend on these variables work in the editor but fail in production.

This commonly manifests as API calls returning authentication errors, integrations silently failing, or features that depend on configuration values behaving differently in the published app.

Your Base44 app was working and publishing fine, but after making recent changes, the build fails when you try to publish. The error message may be vague, pointing to a build step failure without clearly indicating which change caused the problem.

This is especially frustrating when you made multiple changes before attempting to publish, making it difficult to isolate which specific change broke the build. The app may still work in the editor preview, compounding the confusion.

Build failures block you from deploying any updates, including urgent fixes, until the underlying issue is resolved.

You designed an email template in your Base44 app's editor with content, formatting, and dynamic variables, but when the email actually sends, it arrives completely blank or with missing content. The template preview looks correct, but the delivered email is empty.

This creates a terrible impression with your users. They receive professional-looking emails with your branding but zero content — no order details, no welcome message, no information at all. It looks like your app is broken, because it is.

The issue may affect all emails or only those with dynamic content (merge fields, conditional blocks, or images). Sometimes the subject line sends correctly but the body is empty.

When customers reply to emails sent by your Base44 app (order confirmations, support tickets, invoices), their replies go to a noreply@ address, a nonexistent mailbox, or the email service's default address. The replies are silently lost and you never see them.

This is a serious business problem. Customers expect to be able to reply to transactional emails. When they reply to an order confirmation with a question or to a support notification with additional details, they assume someone will read it. Instead, their message disappears into a void.

You may not realize replies are being lost until a customer complains that they've emailed you multiple times with no response, or when you notice customer satisfaction dropping with no apparent cause.

You configured automated email workflows in your Base44 app (welcome emails on signup, order confirmations, status update notifications) but the emails never send. The workflow appears to be set up correctly, the trigger conditions are met, but no emails go out.

Automated emails are often critical to your business: order confirmations build customer trust, status updates keep teams informed, and reminder emails drive user engagement. When they silently fail, customers think you're ignoring them and internal processes break down.

The frustrating part is that there's often no error message — the workflow just doesn't fire, and you only discover it when a customer asks why they didn't receive their confirmation email.

You connected your Base44 app to Zapier using webhooks to automate workflows (new record creates a Slack message, form submission adds to Google Sheets, order triggers Mailchimp email) but the Zapier zap never fires. New records are created in Base44 but nothing happens on the Zapier side.

Webhook integrations are the primary way Base44 apps connect to external services. When they fail, all your automated workflows break: CRM syncing stops, notification pipelines go silent, and the integrations your business depends on quietly stop working.

The failure is often silent. Base44 doesn't report that the webhook call failed, and Zapier shows no incoming data. You only discover it when you notice that downstream actions haven't been happening.

Your Base44 app syncs data to Google Sheets for reporting or external access, but the sync is unreliable. Records are missing from the spreadsheet, some records appear multiple times, data in the sheet doesn't match the app, or the sync stops working entirely after running fine for weeks.

Google Sheets sync is commonly used in Base44 apps for sharing data with team members who prefer spreadsheets, creating reports, feeding data to other tools that read from Sheets, and maintaining backups. When the sync breaks, downstream processes that depend on the spreadsheet data also break.

The issue is especially frustrating because it's non-deterministic. Most records sync correctly, but a random subset is missing or duplicated, making it hard to trust any of the data.

The date picker in your Base44 app is nearly impossible to use on mobile phones. The calendar dropdown is too small to tap accurately, it renders partially off-screen, month navigation arrows are tiny, and selecting a specific date requires pixel-perfect tapping that's unrealistic on a touchscreen.

Date fields are critical in many Base44 apps: booking systems, scheduling, order tracking, and reporting. A broken date picker prevents users from completing forms, filtering data, or scheduling events from their phones.

The issue is compounded when the date picker opens underneath the keyboard or when it doesn't close properly, leaving the user trapped in a state where they can't interact with the rest of the form.

Modals, popups, and dialog boxes in your Base44 app are unusable on mobile devices. The modal content extends beyond the screen with no way to scroll, action buttons at the bottom are hidden below the viewport, and users can't complete the action the modal was designed for.

Modals are used for critical interactions in Base44 apps: editing records, confirming deletions, viewing details, and filling out forms. When they're broken on mobile, users are stuck and can't complete core workflows.

The issue is especially bad on smaller phones (iPhone SE, older Android devices) and when the device keyboard opens inside a modal form, shrinking the visible area to almost nothing.

Data tables in your Base44 app display correctly on desktop but are completely broken on mobile. Columns are cut off with no way to scroll horizontally, text overflows and overlaps other elements, or the table is so compressed that data is unreadable.

Tables are one of the hardest UI elements to make responsive, and Base44's default table components often don't handle narrow screens well. Users on phones can only see the first 2-3 columns and have no way to access the rest of their data.

This is especially problematic for apps where users need to review data on the go: sales dashboards, inventory management, order tracking, and CRM applications.

Your Base44 app's dashboard page with charts and analytics takes an excessively long time to load. Charts show loading spinners for 10+ seconds, and the page may time out entirely when the dataset is large. The dashboard is supposed to provide quick insights but instead becomes the slowest page in the app.

Dashboards typically aggregate data across many records (sums, counts, averages), and each chart may run its own aggregation query. A dashboard with 5-10 charts can trigger dozens of database queries, each scanning large tables.

The problem gets progressively worse as data accumulates, turning a once-fast dashboard into an unusable page over the course of weeks or months.

The search functionality in your Base44 app is either extremely slow (taking several seconds to return results) or returning incorrect/incomplete results. Users can't find records they know exist, or the search returns irrelevant matches.

Search is a core feature for any app with more than a handful of records. Broken or slow search forces users to manually browse through data, which is impractical for large datasets.

The search may also be case-sensitive when users expect it to be case-insensitive, or it may only match exact strings instead of partial matches.

When users try to export data or download files from your Base44 app, the operation times out before completing. CSV exports of large tables fail, PDF report generation hangs, and file downloads from storage timeout for large files.

Data export is often a critical feature for business users who need to work with their data in Excel, generate reports for stakeholders, or create backups. When exports fail, users are stuck without their data.

The exports may work for small datasets but consistently fail once the record count exceeds a certain threshold (often around 1,000-5,000 records).

Changes made to data in your Base44 app are not reflected in real-time on other users' screens. When one user creates or updates a record, other users viewing the same page need to manually refresh to see the changes. This is problematic for collaborative apps where multiple users work on the same data simultaneously.

The lack of real-time updates can cause data conflicts, duplicate work, and confusion among team members. For example, two users might try to claim the same support ticket because neither can see that the other has already taken it.

In some cases, even the same user's screen doesn't update after performing an action, requiring a manual page refresh to see their own changes reflected.

Images in your Base44 app are causing performance problems. Uploading images takes a very long time or fails entirely, and pages with multiple images load extremely slowly. Users with slower internet connections experience the worst effects, with images taking 10+ seconds to appear.

Image-heavy apps (portfolios, product catalogs, real estate listings, etc.) are particularly affected. Each full-resolution image can be several megabytes, and a page displaying 20+ images may need to download 50MB or more of data.

Thumbnail views that should show small preview images are instead loading the full-resolution versions, wasting bandwidth and dramatically slowing down the page.

As your Base44 app has grown, certain operations have started timing out or causing the app to crash. Pages that display data take too long to load, exports fail, and search functionality becomes unusably slow. The app worked fine with a small dataset but degrades significantly with thousands or tens of thousands of records.

This is a common scaling issue with AI-built apps that don't implement data pagination and efficient querying by default. The problem compounds because each new record makes the app slightly slower.

Users may experience browser memory warnings, complete page freezes, or error messages about request timeouts when trying to access large data views.

Pages in your Base44 application take a long time to load, sometimes several seconds or more. Users see loading spinners for extended periods, and the app feels sluggish compared to native websites. This is causing user drop-off and complaints.

Performance issues tend to worsen over time as more data accumulates in the database and more components are added to pages. What started as a fast app during development becomes increasingly slow in production.

The slowness may affect all pages uniformly or be concentrated on specific pages that display a lot of data, have many components, or make multiple API calls.

Your Base44 app's dashboard shows charts, metrics, and KPIs that don't update when new data comes in. Users have to manually refresh the entire page to see current numbers. Sales totals are hours behind, new orders don't appear in charts, and team members make decisions based on stale data.

Dashboards are supposed to be the real-time pulse of your business. When they show yesterday's data, users stop trusting the dashboard and go back to checking the raw data manually, defeating the entire purpose of having a dashboard.

The issue may be that charts loaded data once on page load and never poll for updates, or that aggressive caching is serving stale query results long after the underlying data has changed.

When two team members edit the same record simultaneously in your Base44 app, the last person to save silently overwrites the first person's changes. There's no warning, no conflict detection, and no way to merge changes. Data is lost without anyone knowing until someone notices their edits disappeared.

This is a critical problem for team-oriented Base44 apps: CRM systems where multiple sales reps update the same contact, project management tools where team members update task details, and inventory systems where multiple warehouse staff modify stock counts.

The damage is often invisible. Users make changes they believe are saved, make decisions based on those changes, and only discover days later that their edits were overwritten by a colleague who was editing at the same time.

Your Base44 app has a notification bell icon but it never shows new notifications, always displays zero, or shows an incorrect count. Users miss important updates because the notification system appears empty even when there are unread items waiting for them.

In-app notifications are how users learn about new assignments, status changes, mentions, and deadlines. When the bell is broken, users rely on email (which they may not check promptly) or manual browsing to discover updates. Response times slow down and important items fall through the cracks.

The issue may be that notifications are never created, that they're created but the badge count isn't updated, or that the bell component doesn't poll for new notifications after the initial page load.

Your Base44 app's database tables are readable by anyone, even unauthenticated visitors. Personal information, email addresses, passwords, payment details, and private business data are all accessible by directly querying the database through the app's API layer.

This happens because Base44's default table configuration may not enforce access restrictions, or the access rules were misconfigured during setup. Anyone who discovers the API endpoint or inspects network requests can pull all records from any table.

You might discover this when a user reports seeing other users' data, when you find your data indexed by search engines, or during a security review that reveals all tables are open.

Forms in your Base44 app accept and save any input without validation. Users can submit empty required fields, enter text in number fields, submit absurdly long strings, or inject HTML and scripts into text fields. This corrupts your data and can create security vulnerabilities.

Without validation, your database fills with garbage data: empty email fields, phone numbers with letters, negative quantities, and dates in the wrong format. Reports become unreliable, automated workflows break on bad data, and cleaning up the mess is time-consuming.

Worse, malicious users can inject scripts that execute when other users or admins view the submitted data, potentially stealing sessions or performing actions on their behalf.

Your Base44 app's admin panel, dashboard, or management pages are accessible to anyone who knows or guesses the URL. There is no login requirement, no role check, and no access restriction preventing unauthorized users from viewing sensitive data and performing admin actions.

An attacker who discovers your admin URL (often predictable like /admin, /dashboard, or /manage) can view all user data, modify records, delete content, change settings, and potentially take over your entire application. This is one of the most critical security vulnerabilities possible.

You may not realize this is happening until someone modifies your data, deletes records, or you discover that search engines have indexed your admin pages.

Your Base44 app's image gallery shows broken thumbnail images, displays full-size images instead of thumbnails (causing slow page loads), or shows no images at all. The gallery page takes forever to load because it's downloading dozens of full-resolution images instead of optimized thumbnails.

Image galleries are a common feature in Base44 apps (product catalogs, portfolios, real estate listings) and broken thumbnails make the app feel slow and unprofessional. Users on mobile connections may not be able to load the page at all.

The issue may appear after uploading images in certain formats, after reaching a storage threshold, or when the image processing service can't generate thumbnails fast enough.

When users try to export data as CSV from your Base44 app, the export hangs, times out, or produces an incomplete file with only some of the records. Small tables export fine, but any table with more than a few thousand rows fails consistently.

Data export is essential for reporting, backups, accounting, and compliance. When users can't get their data out of the app, they lose trust in the platform and may need to manually copy records, which is error-prone and time-consuming.

The timeout typically happens because the export tries to load all records into memory at once, serialize them, and send them in a single HTTP response. For large tables, this exceeds memory limits or connection timeouts.

Your Base44 app has scheduled workflows (daily reports, weekly reminders, monthly billing) that either don't run at all, run at the wrong time, or run multiple times. A workflow scheduled for 9 AM runs at 2 AM, a daily digest never fires, or a monthly report generates three times in one day.

Scheduled workflows are the backbone of automated business processes. When they fire at wrong times, reports go out overnight when nobody reads them, reminders arrive at midnight, and billing processes run at unexpected intervals causing duplicate charges or missed payments.

The timezone issue is particularly common: you configure a schedule thinking it's in your local timezone, but the server interprets it as UTC, causing a consistent offset in all your scheduled tasks.

Your Base44 form has conditional logic configured (show shipping fields when 'delivery' is selected, hide company fields for individual customers, display additional questions based on previous answers) but the conditions don't work. Fields that should appear stay hidden, fields that should hide stay visible, and the form behaves the same regardless of user selections.

Conditional forms are essential for creating clean, user-friendly interfaces that don't overwhelm users with irrelevant fields. When conditional logic breaks, users either see an intimidating form with too many fields, or they miss required fields that should have appeared based on their selections.

The issue is particularly disruptive when hidden fields have validation rules — users can't submit the form because a hidden required field has no value, but they can't see the field to fill it in.

Calculated fields in your Base44 app (order totals, discount amounts, tax calculations, derived metrics) display incorrect values. Subtotals don't add up, percentage calculations are off, currency rounding creates discrepancies, and aggregations across related records return wrong numbers.

Wrong calculations in business applications are dangerous because they often go unnoticed. Users trust the numbers the app shows them. Incorrect pricing means you charge customers the wrong amount. Wrong inventory counts mean you sell products you don't have. Incorrect commission calculations mean you pay your team incorrectly.

The errors may be small and consistent (always off by a few cents due to rounding) or large and intermittent (total jumps to zero when a certain condition is met), making them hard to catch during manual testing.

Forms in your Base44 application are not rendering correctly. Fields may appear in the wrong order, some fields are missing entirely, input types are wrong (e.g., a date field showing as a plain text input), or the form layout is distorted with overlapping elements.

This can make data entry impossible or error-prone. Users may submit incomplete or incorrect data because the form doesn't display the right input controls for the data type expected.

The issue may be intermittent, with the form rendering correctly sometimes but breaking after a page refresh or when navigating away and back.

You've added custom CSS or styling to your Base44 app, but the styles are not being applied to the components. Elements remain in their default appearance despite the CSS being present. In some cases, styles apply in the editor but not in the published app, or they apply to some components but not others.

This is frustrating when trying to brand your Base44 app with custom colors, fonts, or layouts that differ from the default theme.

The issue may be subtle: a color might change but font sizes remain default, or a background changes but borders don't, suggesting a specificity or ordering problem with the CSS.

You've set up conditional visibility rules in your Base44 app to show or hide components based on user roles, data values, or form selections, but the rules aren't working correctly. Components that should be hidden are visible, or components that should appear never show up.

Conditional visibility is essential for creating dynamic user experiences, such as showing different dashboards for different user roles or revealing form fields based on previous selections. When these rules break, the app feels static and unprofessional.

The behavior may be inconsistent: rules work on initial page load but break after data changes, or they work for some users but not others.

The navigation menu in your Base44 app doesn't reflect your current page structure. New pages you've added don't appear in the nav, deleted pages still show up as broken links, or the menu order doesn't match what you've configured.

A broken navigation menu is one of the first things users notice and it immediately makes the app feel unfinished or broken. Dead links are especially bad for user experience and credibility.

In some cases, the navigation works in the editor but the published app shows an outdated version of the menu.

Data tables or grid views in your Base44 app are not displaying correctly. Columns may be misaligned, pagination doesn't work, sorting produces wrong results, or the table shows no data despite records existing in the database.

Data tables are central to many Base44 apps for displaying lists of records, orders, users, or any tabular data. When they malfunction, users can't find or manage their data effectively.

The issue may worsen as data grows: a table that works with 10 records breaks with 100, or sorting works on text columns but fails on date or number columns.

Modals, popups, or dialog boxes in your Base44 app are malfunctioning. They may not open when triggered, not close when the X button or overlay is clicked, or appear behind other elements on the page making them invisible or inaccessible.

These issues are particularly problematic for confirmation dialogs ("Are you sure you want to delete?"), form modals (editing a record in a popup), and notification overlays. A modal that won't close can effectively lock the user out of the rest of the page.

Sometimes the modal appears to not open, but it's actually rendering off-screen or behind another element with a higher z-index.

The file upload functionality in your Base44 app is not working correctly. Users attempt to upload files (documents, images, PDFs) but the upload fails silently, hangs indefinitely, or shows an error. In some cases, the upload appears to succeed but the file is not accessible when trying to view or download it later.

File upload is essential for many business apps: document management systems, application forms with attachments, profile picture uploads, and product image management. When it breaks, a key part of your app's functionality is lost.

The issue may be file-type specific (PDFs upload fine but Word documents fail) or size-specific (small files work but anything over a few MB fails).

Your Base44 app needs to support multiple languages or non-English content, but characters are displaying incorrectly, text layout is broken for right-to-left (RTL) languages, or date/number formats don't match the user's locale.

Internationalization issues affect user trust and usability. Garbled characters make the app look broken, and incorrect date formats can cause data entry errors (is 03/04 March 4th or April 3rd?).

The issue may affect both static UI text and dynamic data stored in the database, with different root causes for each.

Your Base44 app looks great on desktop but the layout breaks on mobile devices. Elements overlap, text overflows off the screen, forms are unusable because input fields are too small, and navigation menus don't collapse properly.

Mobile responsiveness is critical since a large percentage of users access web apps on phones and tablets. A broken mobile layout can make your entire app unusable for these users.

The issue may vary across devices: it might look acceptable on a tablet but completely broken on a phone, or it might work on iOS but not Android (or vice versa).