Category: Web Development

Astra Pro makes it easy to build flexible headers, but mobile headers behave very differently from desktop ones. One of the most common problem areas is the combination of a mobile logo and an off-canvas menu.

On paper, the setup looks simple: show a logo, add a hamburger icon, open the menu from the side. In practice, small configuration choices can cause the logo to disappear, overlap the menu toggle, or break alignment on certain screen sizes.

Mobile Logo Looks Fine, But Disappears When Menu Opens

This issue often confuses site owners because everything looks correct until the off-canvas menu is opened.

What usually happens is this:

• the header has a lower z-index than the off-canvas container,
• the menu slides in above the header,
• the logo is technically still there but hidden behind the menu layer.

This is not a bug. Astra treats the off-canvas menu as a separate component.

The fix is to clearly define which element should stay on top:

.site-header {
	position: relative;
	z-index: 1000;
}

.ast-off-canvas-menu {
	z-index: 999;
}

After this change, the logo stays visible while the menu opens.

Logo and Hamburger Icon Overlap on Mobile

This happens most often when:

• the desktop logo is reused on mobile,
• the logo is too wide,
• the header layout is set to center alignment.

Astra does not automatically know how much space your logo needs. When space runs out, elements start overlapping.

The simplest fix is to:

• set a dedicated mobile logo,
• reduce its width,
• align the logo and toggle using flex layout.

@media (max-width: 768px) {
	.ast-mobile-header-content {
		display: flex;
		align-items: center;
		justify-content: space-between;
	}
}

This forces Astra to respect spacing instead of stacking elements.

Logo Is Too Small on Mobile Devices

Astra sometimes scales logos aggressively on small screens, especially when a mobile logo is not defined.

The result is a logo that becomes unreadable.

You can control this manually:

@media (max-width: 768px) {
	.site-header .custom-logo {
		max-width: 140px;
		height: auto;
	}
}

This keeps the logo readable without breaking the header layout.

Off-Canvas Menu Covers the Header Completely

Some sites intentionally want the menu to cover the entire screen. Others don’t.

If your menu covers the logo and header, it usually means:

• the off-canvas menu is set to full height,
• the header is not fixed,
• z-index stacking is not controlled.

To keep the header visible, make sure the header stays above the menu or that the menu opens below it.

In some designs, keeping the header visible helps users orient themselves while navigating.

Logo Moves or Jumps When Scrolling With Menu Open

This is common when:

• the header switches between static and sticky modes,
• the off-canvas menu is fixed,
• the body scroll is not locked.

The result is a “jumping” logo when the menu opens or closes.

In these cases, keeping the header position consistent on mobile usually solves the issue. Avoid mixing sticky headers with full-screen off-canvas menus unless absolutely needed.

Mobile Header Breaks Only on Certain Screen Sizes

Some issues only appear between specific widths, for example between 768px and 920px.

This usually happens when:

• custom CSS uses fixed breakpoints,
• Astra uses slightly different breakpoints internally,
• desktop styles leak into mobile.

Always check your custom CSS media queries and align them with Astra’s mobile breakpoint.

Custom Header Builder Conflicts With Astra Header

If you are using Elementor or another builder to create a custom header, Astra’s default mobile header may still load underneath.

This causes:

• duplicate logos,
• overlapping menus,
• broken off-canvas behavior.

In these cases, you should either:

• disable Astra’s header completely, or
• rely only on Astra’s header system.

Mixing both almost always causes mobile-only issues.

Logo Click Area Is Not Clickable

Sometimes the logo looks fine, but tapping it does nothing.

This often happens because:

• the menu toggle overlaps the logo area,
• an invisible element sits on top of the logo,
• z-index values conflict.

Inspecting the header in mobile view usually reveals the issue. Adjusting spacing or z-index fixes it quickly.

Off-Canvas Menu Opens, But Header Shifts

This usually means:

• the body scrollbar disappears,
• padding changes when the menu opens,
• layout is not locked properly.

Keeping consistent padding and avoiding layout shifts makes the menu feel more stable.

Everything Looks Fine in Preview, But Broken on Real Devices

Browser resizing is not the same as real mobile testing.

Always test:

• iOS and Android if possible,
• menu open and closed states,
• scrolling behavior,
• tap areas, not just visuals.

Many Astra mobile issues only appear on real devices.

1. Why does the mobile logo disappear when the off-canvas menu opens in Astra?

This usually happens because the off-canvas menu is layered above the header. The logo is still present in the markup, but it gets hidden behind the menu container. Adjusting the z-index order between the header and the off-canvas menu typically resolves this issue.

2. Do I need to upload a separate logo for mobile in Astra Pro?

Yes, using a dedicated mobile logo is highly recommended. It gives you better control over size and spacing on small screens and prevents Astra from auto-scaling the desktop logo. This often fixes alignment issues without any custom code.

3. Why do the logo and hamburger icon overlap on mobile devices?

This happens when the logo is too wide for the mobile header or when the layout alignment is not balanced. Astra does not automatically adjust spacing when screen width becomes very limited. Reducing logo width or adjusting the mobile header layout usually fixes the overlap.

4. Can I keep the logo visible while the off-canvas menu is open?

Yes, it is possible to keep the logo visible while the menu is open. This requires controlling the layering so the header stays above the menu container. Many sites choose this approach to keep branding visible during navigation.

5. Is this issue caused by Astra Pro or custom CSS?

In most cases, the issue is caused by custom CSS rather than Astra itself. Desktop-focused styles often override mobile header behavior unintentionally. Reviewing media queries usually reveals the problem quickly.

6. Why does the mobile header look fine in preview but broken on real devices?

Browser resizing does not always reflect real mobile behavior. Touch areas, viewport height, and scrolling work differently on actual devices. Testing on real phones often reveals issues that previews miss.

7. Does using a sticky header on mobile cause off-canvas menu issues?

It can. Sticky headers add another positioning layer that may conflict with the off-canvas menu. If you notice jumping or layout shifts, disabling sticky behavior on mobile is often the easiest fix.

8. Can I use a custom Elementor header together with Astra’s mobile header?

Mixing a custom header with Astra’s built-in header usually causes conflicts. Duplicate logos, overlapping menus, and broken alignment are common results. It is best to use one header system consistently.

9. Will fixing the mobile header affect the desktop layout?

Not if the changes are properly scoped to mobile breakpoints. Using media queries ensures desktop layouts remain unchanged. Always test both views after making adjustments.

10. When should I consider rebuilding the header instead of fixing it?

If the header uses multiple systems and many overrides, rebuilding can be faster and cleaner. For smaller issues, targeted fixes are usually enough. The decision depends on how complex the current setup is.

Many WordPress websites serve users from multiple countries. When that happens, email communication often needs to change depending on where the user is located.

A very common requirement looks like this:

1. If a user selects China in a Contact Form 7 form, the site should send one email template.
2. If the user selects any other country, the site should send a different template.

This sounds simple, but Contact Form 7 does not support country-based email templates by default. There is no built-in setting for conditional email content, and there is no visual toggle to switch templates based on user input.

Still, this problem can be solved cleanly, safely, and in a way that is easy to maintain long-term.

Why you should use Country Based Email Templates

On international websites, email content is rarely one-size-fits-all. Country-based email templates are often required for legal, operational, or communication reasons.

In practice, this requirement appears on many types of websites.

Some businesses need different wording for certain regions. Others must include extra notices or disclaimers depending on country. In some cases, emails need to be routed to different internal teams based on geography.

Below are the most common real-world reasons developers implement country-based email templates.

Before listing them, it’s important to understand that these needs usually appear after a site starts growing internationally. That’s why this problem shows up frequently in mature projects.

Common reasons include:

• Different legal or compliance text by country
• Local sales or support teams handling different regions
• Language or cultural tone differences
• Special handling for specific markets (for example, China)
• Internal workflows that depend on user location

After implementing country-based logic once, it often becomes reusable across many forms and projects.

Why Contact Form 7 Cannot Do This by Default

Contact Form 7 is designed to be minimal. It focuses on form submission, validation, and email delivery, but avoids complex conditional logic in the interface.

Out of the box, Contact Form 7 allows:

• One main email template
• One optional secondary email (Mail 2)
• Static subject and body fields
• No conditions inside email content

Even though there is a “Mail (2)” option, Contact Form 7 does not let you decide dynamically which email template should be used based on a submitted value like country.

This is why developers rely on WordPress hooks.

Hooks allow you to modify data while it is being processed. In this case, we modify the email content right before it is sent.

The Best Hook for Country Based Email Logic

Contact Form 7 provides several hooks, but only one is ideal for this task.

The correct hook is:

wpcf7_mail_components

This hook runs after the form is submitted and validated, but before the email is sent. At that moment, all submitted data is available, and the email content is already prepared.

This allows us to:

• Read the selected country
• Decide which template should be used
• Replace the subject and body dynamically

This approach does not interfere with form validation, spam protection, or submission tracking.

How the Country-Based Email Logic Works

Before going into code, it helps to understand the logic in plain language.

When a user submits a form:

1. The form sends all field values to WordPress.
2. Contact Form 7 prepares the email using the template from the Mail tab.
3. Before sending the email, WordPress runs the wpcf7_mail_components filter.
4. Our code checks the selected country.
5. If the country matches a specific value (for example, China), the email content is replaced.
6. If not, the default email remains unchanged.

This means:

You still have one form.
You still edit templates in one place.
The logic is invisible to the user.

Step 1: Make Sure Your Form Has a Country Field

The first requirement is simple. Your Contact Form 7 form must include a country field.

The field can be a dropdown, a text input, or any other supported type. What matters most is the field name.

Here is a common example using a dropdown:

[select* country "China" "United States" "Canada" "Germany" "France" "Other"]

In this example, the field name is country.

That name will be used later in the code. If your field uses a different name, such as your-country, the code must be adjusted accordingly.

After adding or confirming the country field, you should test the form normally to make sure submissions work as expected.

Step 2: Decide Where Email Templates Should Live

Before writing any code, you need to decide where your email templates will be stored.

This decision affects maintainability and client usability.

There are multiple technical options, but not all are equally practical.

Below is an overview of common approaches, followed by an explanation of which one is recommended.

Possible storage options include:

• Hardcoding templates directly in PHP
• Storing templates inside Contact Form 7 Mail settings
• Loading templates from theme files
• Saving templates in WordPress options or custom fields

While all of these work technically, only one is truly client-friendly.

The recommended approach is to store the default email template inside Contact Form 7, and let the code override it only when a specific country is selected.

This allows non-developers to edit email content without touching PHP.

Step 3: Set Up the Default Email Template (All Countries)

Start by configuring the standard email template in the Contact Form 7 Mail tab.

This template will be used for all countries except China.

Use clear, neutral wording that works globally.

Example subject:

Thank you for contacting us

Example body:

Hello,

Thank you for reaching out.
Our team has received your message and will respond shortly.

Best regards,
Company Name

This email becomes the fallback template. If no country-specific condition is matched, this is the email that will be sent.

Step 4: Add Country-Based Logic with wpcf7_mail_components

Now comes the technical part. This code only needs to be written once.

It should be added to:

• a custom plugin, or
• the theme’s functions.php file

Using a custom plugin is recommended for long-term projects.

Here is a clean, production-safe example:

add_filter( 'wpcf7_mail_components', 'cf7_country_based_email_template', 10, 3 );

function cf7_country_based_email_template( $components, $contact_form, $instance ) {

    $submission = WPCF7_Submission::get_instance();
    if ( ! $submission ) {
        return $components;
    }

    $posted_data = $submission->get_posted_data();

    if ( empty( $posted_data['country'] ) ) {
        return $components;
    }

    $country = strtolower( trim( $posted_data['country'] ) );

    if ( $country === 'china' ) {

        $components['subject'] = 'Thank you for contacting our China team';

        $components['body'] =
            "Hello,\n\n" .
            "Thank you for contacting us from China.\n" .
            "Your message has been forwarded to our regional team.\n\n" .
            "Best regards,\n" .
            "Company Name";
    }

    return $components;
}

What This Code Actually Does

Even if you are not a developer, it helps to understand what is happening.

1. First, the code waits until Contact Form 7 prepares the email.
2. Then it reads the submitted form data.
3. Next, it looks specifically for the country field.
4. If the value equals “China”, the subject and body are replaced.
5. If not, the email stays exactly as defined in the Mail tab.

Nothing else is changed.

Attachments, headers, sender address, and recipients remain untouched.

Expanding the Logic for More Countries

Once this logic exists, expanding it is easy.

You can support multiple countries with one condition.
You can also group countries by region.

For example, China-related regions:

$china_group = array( 'china', 'hong kong', 'macau' );

if ( in_array( $country, $china_group, true ) ) {
    // China template
}

This approach keeps the logic readable and easy to maintain.

Why This Approach Is Better Than Multiple Forms

Many site owners try to solve this problem by duplicating forms.

That usually creates more problems than it solves.

Before listing the issues, it’s important to note that form duplication also hurts SEO and maintainability.

Problems caused by multiple forms include:

• Harder updates when content changes
• Inconsistent email formatting
• Higher chance of configuration errors
• More testing required
• Worse editorial control

Using one form with country-based logic avoids all of these issues.

Common Mistakes to Avoid

This solution is reliable, but there are common mistakes that can cause issues if not avoided.

First, email logic must always run on the server. Client-side JavaScript cannot control email delivery.

Second, country values must be normalized. Differences in capitalization or spacing can break comparisons.

Third, logic should be kept simple. Over-engineering email templates leads to fragile systems.

Keeping the code short and clear improves long-term stability.

Contact Form 7 does not support country-based email templates by default, but WordPress hooks make it possible.

But with a small amount of code, you can:

• Send different emails based on country
• Keep one clean form
• Let clients edit templates safely
• Avoid unnecessary plugins
• Build a scalable solution

Once implemented, this logic rarely needs changes.

Need Help Implementing This Safely?

If you want this set up correctly on a live site, or if you need:

• more complex country rules
• multilingual email content
• CRM or automation integration
• a future-proof implementation

You can post your request on Codeable and receive a free estimate with no obligation to proceed with project

If you’re using the Amelia booking plugin on WordPress and relying on Outlook / Microsoft 365 for scheduling, you may have run into a frustrating issue:
appointments appear in Outlook, but important details are missing, or worse, the booking never shows up at all (Amelia Outlook Calendar Not Syncing)

This is one of the most common problems reported by businesses using Amelia with Microsoft Outlook. The good news is that in most cases, the issue is fixable. The bad news is that it’s rarely caused by just one setting.

How Amelia Outlook Calendar Sync Works

What Data Amelia Sends to Outlook

When a customer books an appointment, Amelia collects:

• Appointment date and time
• Service name
• Customer name and email
• Phone number
• Custom form fields (reason for appointment, notes, etc.)

This data is then sent to Outlook via the Microsoft 365 API to create a calendar event.

What Outlook Accepts by Default

Outlook calendar events are more limited than most people expect. Typically, they support:

• Event title
• Event description (notes/body)
• Date and time
• Organizer
• Location

If Amelia isn’t explicitly told where to place customer data (for example, into the event description), Outlook may create a valid event with very little information visible.

This mismatch is the root of many sync problems.

Common Amelia Outlook Sync Problems

Appointment Time Appears but Details Are Missing (Amelia Outlook Calendar Not Syncing)

This is the most common situation.
The event exists in Outlook, but the calendar entry contains:

• No client name
• No contact details
• No reason for appointment or other custom fields

From Outlook’s perspective, nothing is broken, but from a business workflow perspective, it’s unusable.

Appointment Does Not Appear in Outlook at All

In this case, Amelia appears to be working, but:

• No event is created in Outlook
• Or it appears in a different calendar than expected

This often happens when multiple calendars or shared mailboxes are involved.

Sync Works for Some Bookings but Not Others

Sometimes:

• One service syncs correctly
• Another doesn’t
• Or only some staff calendars update

This usually points to configuration inconsistencies rather than a global failure.

Root Causes of Amelia Outlook Calendar Sync Issues

Incorrect Field Mapping in Amelia

Amelia allows control over what appears in:

• Event title
• Event description

If customer data and custom fields aren’t mapped into the event description, Outlook will never display them—because Outlook doesn’t “know” about Amelia’s internal data structure.

This is not a bug; it’s a configuration issue.

Microsoft 365 Permissions and API Limitations

Outlook integration depends heavily on permissions granted during authorization.

Common problems include:

• Authorization completed without full admin consent
• Token created by a non-admin user
• Limited permissions that allow event creation but not full data writing

In these cases, Outlook may accept a basic event but silently drop additional data.

Shared vs Default Outlook Calendar Confusion

Many businesses use:

• Shared calendars
• Group calendars
• Delegate access

Amelia typically syncs with the primary calendar of the connected account. If staff members are checking a shared calendar instead, it may look like the sync is broken—even when it isn’t.

Token Expiry or Broken Authorization

Microsoft tokens can expire or become invalid without obvious errors.

Symptoms include:

• Sync worked in the past
• No changes were made
• Suddenly events stop appearing or lose data

Re-authorizing the integration often resolves Amelia Outlook Calendar Not Syncing issue

Plugin, Security, or Caching Conflicts

Less common, but still relevant:

• Security plugins blocking REST API requests
• Aggressive caching interfering with webhook responses
• Firewall rules preventing API calls

These issues usually affect all bookings, not just some.

Step 1: Confirm Which Outlook Calendar Amelia Is Actually Syncing With

The first and most common reason people believe Amelia is “not syncing” with Outlook is simple: the booking is being written to a different calendar than the one being viewed. This is not an Amelia bug—it’s a misunderstanding caused by how Microsoft 365 handles calendars.

In many organizations, Outlook is not just “one calendar.” There are often:

• A primary (default) calendar tied to a user account
• One or more shared calendars
• Microsoft 365 Group calendars
• Shared mailboxes like info@, bookings@, or admin@

Amelia typically syncs with the primary calendar of the Microsoft account that was authorized during setup. If staff members are checking a shared calendar instead, it will appear as though bookings are missing—even though they exist.

What to Check First

Start by identifying:

1. Which Microsoft 365 account is connected to Amelia
2. Which calendar that account uses as its primary calendar
3. Which calendar staff members are actually viewing

Log into Outlook using the connected account and expand the full calendar list. Do not rely on a filtered or mobile view. Then create a real test booking through the website and observe where the event appears.

Common Pitfalls

• The event is created in the admin’s primary calendar, but staff check a shared “Appointments” calendar.
• Outlook mobile apps show only one calendar by default.
• Calendar views are filtered by category, privacy, or time range.
• Time zone mismatches make bookings appear on a different day.

If you skip this step, you may waste hours adjusting permissions or mapping fields when the sync is already working correctly. In real-world projects, this single check resolves a large percentage of “Amelia Outlook Calendar Not Syncing” complaints.

Once you confirm the correct calendar, you can decide whether:

• Staff should switch to viewing that calendar, or
• The integration needs to be reconfigured to match how the business operates

Step 2: Re-Authorize the Microsoft 365 Connection With Proper Permissions

Microsoft 365 integrations rely on OAuth authorization and API permissions, and this is another major point of failure. Amelia may appear connected, but the permissions granted are often insufficient for full data sync.

This happens when:

• The connection was set up using a non-admin user
• Admin consent was never granted
• Security policies were changed after initial setup
• Tokens expired silently due to password or MFA changes

In these cases, Outlook may accept a basic event (date/time), but discard or ignore extended data such as customer details and custom fields.

Best Practice for Re-Authorization

To fix this properly:

1. Disconnect the existing Outlook/Microsoft 365 integration in Amelia.
2. Reconnect using a Microsoft 365 admin account or a user with full calendar permissions.
3. During authorization, ensure all requested permissions are approved.
4. Avoid using shared mailboxes as the authenticating account whenever possible.

After reconnecting, always create a new test booking. Do not rely on existing bookings, as they may have been created under the old token.

Why Re-Authorization Works So Often

Microsoft tokens can become partially invalid. When this happens, there is often no visible error message. Amelia sends the data, Outlook creates the event—but the payload is incomplete.

Re-authorizing refreshes:

• Permissions
• Token scope
• API access to extended fields

This step alone frequently resolves issues where bookings appear but lack details.

Step 3: Explicitly Map Booking Data Into the Outlook Event

Outlook does not automatically understand Amelia’s internal data structure. If you want customer details to appear in Outlook, you must explicitly send them there.

By default, Outlook events support:

• Event title
• Event description (body)
• Date/time
• Organizer

Amelia custom fields (phone number, reason for appointment, notes) will not appear unless they are injected into the event description.

What Needs to Be Configured

Inside Amelia’s settings:

• Define what appears in the event title
• Define what appears in the event description
• Insert placeholders for:
  • Customer name
  • Email
  • Phone
  • Custom fields (reason for appointment, notes, etc.)

If these placeholders are missing, Outlook will create a valid event—but it will look empty.

Common Mistakes

• Assuming Outlook will “pull” customer data automatically
• Adding custom fields to the booking form but not to the event template
• Expecting fields to appear in separate Outlook properties (they won’t)

Best Practice

Treat the Outlook event description as a structured summary of the booking. Include all critical information there in a readable format.

After updating the configuration, create a new booking and verify that:

• The event description contains all required details
• Formatting is readable
• No critical data is missing

On Codeable, you can describe your Amelia and Outlook calendar sync issue in detail. You can discuss possible solutions with experienced WordPress experts who understand booking systems and Microsoft 365 integrations. You’ll receive a free, no-obligation estimate before deciding how you’d like to proceed.

Step 4: Test With Real-World Booking Scenarios

Testing is often rushed, which leads to false conclusions. Amelia–Outlook sync issues can vary depending on:

• Service type
• Employee assignment
• Custom fields
• Calendar ownership

You should always test using real booking scenarios, not partial or dummy data.

How to Test Properly

Create multiple test bookings:

• Different services
• Different employees
• Full form completion
• Real email addresses

Then verify:

• The event appears in the correct calendar
• Date and time are correct
• Event description contains all details
• No duplication or overwriting occurs

Why This Matters

Some issues only appear when:

• Multiple employees are involved
• Shared calendars are used
• Conditional fields are triggered

Testing only one scenario can give a false sense of success.

Step 5: Review Custom Fields, Shared Calendars, and Edge Cases

If problems persist after configuration and testing, the issue is usually structural rather than accidental.

Custom Field Limitations

Not all custom fields are equal. Some field types:

• Are not supported by Outlook APIs
• May be truncated or ignored
• Must be manually formatted into text

Simplify where possible.

Shared Calendar Constraints

Microsoft treats shared calendars differently than primary calendars. Even with correct permissions, some metadata may not sync as expected. This is a Microsoft limitation, not an Amelia defect.

When to Escalate

If the business requires:

• Full data sync into shared calendars
• Multiple staff calendars
• Advanced automation

You may need:

• Amelia support confirmation
• Power Automate or middleware solutions
• Custom development

Special Case: Amelia and Shared Outlook Calendars

Why Shared Calendars Cause Issues

Microsoft’s API treats shared calendars differently from primary calendars.
Even when permissions appear correct, some event attributes may not be written as expected.

This is a Microsoft limitation, not an Amelia bug.

Possible Workarounds

Depending on the setup:

• Sync to the primary calendar and share it internally
• Use forwarding rules
• Use automation tools (e.g., Power Automate) to enrich calendar events

These solutions add complexity and should be evaluated carefully.

When Amelia Support or Custom Development Is Needed

When Configuration Alone Is Not Enough

You may need advanced help if:

• Multiple shared calendars are required
• Custom data must appear in specific Outlook fields
• Microsoft permissions are locked down by IT policies

At this point, configuration reaches its limits.

Custom Solutions (High-Level)

Possible approaches include:

• Amelia webhooks
• Custom handlers for calendar events
• Middleware integrations

These are not typical for small sites but can be justified for complex organizations.

Best Practices to Avoid Outlook Sync Issues in the Future

• Keep booking forms focused and minimal
• Document required calendar fields
• Test integrations after plugin updates
• Avoid unnecessary calendar complexity
• Recheck permissions annually

A stable setup saves time long-term.

Perfect — below is a fully expanded FAQ section, written in clear English, SEO-friendly, and suitable for Rank Math FAQ schema.
Each answer is detailed, practical, and long-form (not one-liners), so you can use it both for SEO and real user trust.

Frequently Asked Questions About Amelia and Outlook Calendar Sync

Does Amelia fully support Outlook / Microsoft 365 calendar sync?

Yes, Amelia does support Outlook and Microsoft 365 calendar synchronization, but it’s important to understand what “support” actually means in practice.

Amelia integrates with Microsoft 365 using Microsoft’s official calendar APIs. This allows Amelia to create, update, and remove calendar events when bookings are made, rescheduled, or canceled. However, the behavior of that integration is limited by Microsoft’s API rules, not by Amelia itself.

This means Amelia can reliably:

• Create calendar events
• Set date and time
• Assign an organizer
• Write content into the event title and description

What Amelia cannot control is:

• How Outlook internally stores or displays extended metadata
• How shared calendars handle permissions
• How Microsoft restricts access to certain event properties

So when users say “Amelia doesn’t fully support Outlook,” the reality is usually that Microsoft does not expose the same flexibility as Google Calendar. Amelia works within those constraints.

In short:
Amelia supports Outlook sync correctly, but expectations must align with Microsoft 365’s technical limitations and sometimes Amelia Outlook Calendar Not Syncing issues may arise

Why do Amelia bookings appear in Outlook without customer details?

This is the single most common complaint, and in almost every case it is not a bug.

Outlook calendar events do not automatically know about Amelia’s booking form fields. Amelia collects customer data internally, but Outlook will only display what is explicitly sent to it.

If customer details (name, phone, email, reason for appointment) are missing, it usually means:

• Those fields were not added to the Outlook event description template
• Amelia was only configured to send basic event data (date/time)

Outlook does not have separate native fields for “customer phone” or “reason for appointment.” Everything must be passed as plain text into the event body (description).

Once those fields are properly mapped and included in the event description, Outlook will display them consistently.

Can custom booking fields appear in Outlook calendar events?

Yes — but only as text inside the event description.

This is a critical limitation to understand. Outlook does not allow third-party apps like Amelia to create custom structured fields inside calendar events. That means:

• No separate Outlook field for “Reason for appointment”
• No native “Customer notes” field
• No custom metadata panel

All custom booking fields must be:

• Converted to text
• Inserted into the event description/body

If a business requires structured data inside Outlook itself, that is outside the scope of Amelia and would require Microsoft-specific automation or custom development.

For most businesses, placing all relevant information clearly inside the event description is more than sufficient.

Why does Amelia work perfectly with Google Calendar but not with Outlook?

This difference is caused by API design, not by Amelia.

Google Calendar’s API is more flexible and forgiving. It allows:

• Richer metadata handling
• Better support for extended descriptions
• Fewer permission edge cases

Microsoft 365, on the other hand:

• Has stricter permission models
• Handles shared calendars differently
• Limits how third-party apps interact with events

As a result, many users experience:

• Seamless Google Calendar sync
• Partial or inconsistent Outlook sync

This does not mean Outlook is broken — it means it is more restrictive by design.

Does Amelia support shared Outlook calendars?

Partially — and this is where many issues begin.

Amelia works best when syncing to a primary calendar of a user account. Shared calendars, group calendars, and resource calendars behave differently in Microsoft 365.

Common shared-calendar issues include:

• Events appearing without full details
• Events syncing to the wrong calendar
• Permissions that look correct but still block data

Even when permissions are technically correct, Microsoft may restrict what data can be written to shared calendars via API.

If a business relies heavily on shared calendars, expectations should be set early that:

• Some limitations may exist
• Workarounds may be required
• Full parity with Google Calendar is unlikely

Why do appointments sync for some staff but not others?

This usually indicates configuration inconsistency, not random failure.

Typical causes include:

• Different employees connected to different Outlook accounts
• Some calendars being primary, others shared
• Permissions granted to one account but not another
• Employees viewing different calendars in Outlook

Each employee in Amelia may have:

• A separate Outlook connection
• A different calendar setup
• Different permission levels

To resolve this, each staff calendar must be reviewed individually, and testing must be done per employee.

Do I need Microsoft 365 admin access to fix Outlook sync issues?

In most professional setups, yes.

Many Outlook sync problems cannot be fully resolved without:

• Admin consent for API permissions
• Access to Microsoft Entra (Azure AD) settings
• Ability to re-authorize connections properly

Without admin access, you may be able to:

• Create events
• See partial sync working

But you may not be able to:

• Fix missing data
• Resolve shared calendar limitations
• Correct permission-related failures

For agencies and developers, requesting admin access early saves time and avoids guesswork.

How long does it usually take to fix Amelia–Outlook sync issues?

It depends on the setup, but realistic timeframes are:

• 1–2 hours
  Simple issues such as wrong calendar, missing field mapping, or expired token.
• 3–6 hours
  Permission issues, re-authorization, shared calendar testing, multiple employees.
• 6–12 hours or more
  Complex Microsoft 365 environments, shared mailboxes, automation requirements, or custom workflows.

Most fixes fall into the first two categories when approached methodically.

Is this an Amelia bug or a Microsoft limitation?

In the majority of cases, it is a Microsoft limitation or configuration issue, not an Amelia bug.

Amelia sends the data correctly. What happens next depends on:

• Microsoft’s API rules
• Permission scope
• Calendar type
• Account structure

Understanding this distinction helps prevent frustration and unrealistic expectations.

When is custom development or automation required?

Custom solutions may be needed when:

• All booking data must appear in shared calendars
• Multiple departments rely on different calendar views
• Outlook events must trigger additional workflows

In these cases, tools like:

• Microsoft Power Automate
• Webhooks
• Middleware integrations

may be considered. This goes beyond standard plugin configuration and should be scoped carefully.

Amelia Outlook calendar sync problems are common—but rarely unsolvable.

Most issues come down to:

• Field mapping
• Permissions
• Calendar selection

With a structured approach, you can restore full functionality and ensure that every appointment arrives with the information your team actually needs.

On Codeable, you can describe your problem, discuss it with experienced WordPress experts, and receive a free, no-obligation estimate before deciding how to proceed.

Woffice Customization for WordPress Intranets and Extranets

Woffice is a powerful WordPress theme built for intranets, extranets, communities, and internal tools.
It combines dashboards, user profiles, BuddyPress, project features, and access control into one platform.

While it works well out of the box, in real-world projects default behavior is almost never enough.
Every company, team, or community has its own workflow, rules, and structure.
That is where Woffice customization becomes essential.

Why Woffice Customization Is Almost Always Needed

Woffice is designed to support many different use cases: companies, schools, teams, online communities, and membership platforms.
Because of that flexibility, it cannot perfectly match any single workflow by default.

Customization allows you to adapt Woffice to your real business logic instead of forcing users to adapt to the theme.

Customization allows you to:

• Remove friction for users
• Match internal processes and workflows
• Improve performance and load times
• Avoid unnecessary plugin overload
• Keep long-term stability during updates

Without proper customization, many Woffice sites feel overloaded, confusing, or slow, which reduces user adoption and trust.

Custom Dashboard Widgets in Woffice

The dashboard is the first thing users see after login.
If the dashboard is cluttered or shows irrelevant information, users get lost very quickly.

By default, Woffice displays generic widgets.
In real projects, teams usually need context-aware dashboards that change based on role, user data, or activity.

Common real-world needs include:

• Internal announcements and notices
• User-specific data and profile information
• Quick links to internal tools
• Project, task, or course status

A well-designed dashboard answers one simple question:
“What should I do next?”

Common Dashboard Customizations

Most organizations customize dashboards to reduce noise and focus users on what matters most.

• Show different widgets for admins vs members
• Display user meta such as department, role, or progress
• Remove widgets that confuse or overwhelm users
• Add company-specific announcements or alerts

These changes improve clarity, reduce support requests, and increase daily usage.

Example: Add a Custom Dashboard Widget

This example adds a simple announcement widget to the Woffice dashboard.

add_action('woffice_dashboard_widgets', function () {
    echo '<div class="woffice-widget">';
    echo '<h3>Company Updates</h3>';
    echo '<p>Please submit your weekly report by Friday.</p>';
    echo '</div>';
});

This approach works well for internal updates that should not be sent by email.

Example: Show Dashboard Widget Only to Admins

In many Woffice intranets, admin-only information should not be visible to regular users.

add_action('woffice_dashboard_widgets', function () {
    if (!current_user_can('administrator')) {
        return;
    }

    echo '<div class="woffice-widget">';
    echo '<h3>Admin Notes</h3>';
    echo '<p>Review pending user requests.</p>';
    echo '</div>';
});

Role-based widgets keep dashboards clean and relevant.

Custom User Fields and Profile Data

Before adding custom fields, it is important to understand why default user profiles are rarely enough.

Most organizations need structured user data, not just name and email.
Woffice often integrates with BuddyPress, but real-world projects almost always require additional custom fields.

Common Custom User Fields

These fields are frequently used in Woffice intranets and extranets:

• Department or team
• Employee or member ID
• Internal notes (admin only)
• Certification or training level
• Enrollment or access flags

Custom user fields can be reused across dashboards, reports, permissions, and automation rules.

Example: Save a Custom User Field

This example stores a department value in user meta.

update_user_meta($user_id, 'department', 'Marketing');

This is commonly done during registration, onboarding, or profile updates.

Example: Display User Meta on the Dashboard

$user_id = get_current_user_id();
$department = get_user_meta($user_id, 'department', true);

if ($department) {
    echo '<p>Your department: ' . esc_html($department) . '</p>';
}

Showing personalized data makes the dashboard feel relevant and professional.

Layout and UI Adjustments

When customizing layout and design, always remember one rule:
Never edit the main Woffice theme files.

Safe layout customization should always be done using:

• Child themes
• Custom CSS
• WordPress hooks and filters

This approach keeps your site update-safe and stable.

Why UI Customization Matters

Many Woffice sites fail because the interface is too busy or unclear.

• Too many widgets
• Buttons that are too small
• Poor spacing and alignment
• No clear visual hierarchy

Users do not need more features. They need clarity and simplicity.

Example: Add a Custom Body Class

add_filter('body_class', function ($classes) {
    $classes[] = 'woffice-custom-ui';
    return $classes;
});

This allows you to safely target Woffice pages with custom CSS.

Example: Simple UI Cleanup With CSS

.woffice-custom-ui .widget-unused {
    display: none;
}

.woffice-custom-ui .dashboard-button {
    font-size: 18px;
    padding: 14px 20px;
}

Small UI changes like this can dramatically improve user experience.

Performance Optimization for Woffice

Before optimization, many Woffice sites feel slow because they load everything everywhere.

Performance is not just a technical concern. It directly affects:

• User trust
• Engagement and adoption
• SEO and Core Web Vitals

Example: Disable Heavy Scripts for Guests

add_action('wp_enqueue_scripts', function () {
    if (!is_user_logged_in()) {
        wp_dequeue_script('buddy-press');
    }
}, 100);

This reduces unnecessary load on public pages.

When You Should Not Customize Alone

Some Woffice customizations are not beginner-friendly and can cause serious issues if done incorrectly.

• Deep BuddyPress customization
• Complex dashboards and logic
• Advanced performance tuning
• Security and access control
• Multi-role permission systems

If done wrong, these can break updates, slow the site, or create security risks.