Tag: scheduling

Make.com: Time and Date Functions Explained guides us through setting variables, formatting timestamps, and handling different time zones on Make.com in a friendly, practical way.

As a follow-up to the previous video on time zones, let’s tackle common questions about converting and managing time within the platform and try practical examples for automations. Jannis Moore’s video for AI Automation pairs clear explanations with hands-on steps to help us automate time handling.

Make.com Date and Time Functions Overview

We’ll start with a high-level view of what Make.com offers for date and time handling and why these capabilities matter for our automations. Make.com gives us a set of built-in fields and expression-based functions that let us read, convert, manipulate, and present dates and times across scenarios. These capabilities let us keep schedules accurate, timestamps consistent, and integrations predictable.

Purpose and scope of Make.com’s date/time capabilities

We use Make.com date/time capabilities to normalize incoming dates, schedule actions, compute time windows, and timestamp events for logs and audits. The scope covers parsing strings into usable date objects, formatting dates for output, performing arithmetic (add/subtract), converting time zones, and calculating differences or durations.

Where date/time functions are used within scenarios and modules

We apply date/time functions at many points: triggers that filter incoming events, mapping fields between modules, conditional routers that check deadlines, scheduling modules that set next run times, and output modules that send formatted timestamps to emails, databases, or APIs. Anywhere a module accepts or produces a date, we can use functions to transform it.

Difference between built-in module fields and expression functions

We distinguish built-in module fields (predefined date inputs or outputs supplied by modules) from expression functions (user-defined transformations inside Make.com’s expression editor). Built-in fields are convenient and often already normalized; expression functions give us power and flexibility to parse, format, or compute values that modules don’t expose natively.

Common use cases: scheduling, logging, data normalization

Our common use cases include scheduling tasks and reminders, logging events with consistent timestamps, normalizing varied incoming date formats from APIs or CSVs, computing deadlines, and generating human-friendly reports. These patterns recur across customer notifications, billing cycles, and integration syncs.

Brief list of commonly used operations (formatting, parsing, arithmetic, time zone conversion)

We frequently perform formatting for display, parsing incoming strings, arithmetic like adding days or hours, calculating differences between dates, and converting between time zones (UTC ↔ local). Other typical operations include converting epoch timestamps to readable strings and serializing dates for JSON payloads.

Understanding Timestamps and Date Objects

We’ll clarify what timestamps and date objects represent and how we should think about different representations when designing scenarios.

What a timestamp is and common epoch formats

A timestamp is a numeric representation of a specific instant, often measured as seconds or milliseconds since an epoch (commonly the Unix epoch starting January 1, 1970). APIs and systems may use seconds (e.g., 1678000000) or milliseconds (e.g., 1678000000000); knowing which epoch unit is critical to correct conversions.

ISO 8601 and why Make.com often uses it

ISO 8601 is a standardized, unambiguous textual format for dates and times (e.g., 2025-03-05T14:30:00Z). Make.com and many integrations favor ISO 8601 because it includes time zone information, sorts lexicographically, and is widely supported by APIs and libraries, reducing ambiguity.

Differences between string dates, Date objects, and numeric timestamps

We treat string dates as human- or API-readable text, date objects as internal representations that allow arithmetic, and numeric timestamps as precise epoch counts. Each has strengths: strings are for display, date objects for computation, and numeric timestamps for compact storage or cross-language exchange.

When to use timestamp vs formatted date strings

We prefer numeric timestamps for internal storage, comparisons, and sorting because they avoid locale issues. We use formatted date strings for reports, emails, and API payloads that expect a textual format. We convert between them as needed when mapping between systems.

Converting between representations for storage and display

Our typical approach is to normalize incoming dates to a canonical internal form (often UTC timestamp), persist that value, and then format on output for display or API compatibility. This two-step pattern minimizes ambiguity and makes downstream transformations predictable.

Parsing Dates: Converting Strings to Date Objects

Parsing is a critical first step when dates arrive from user input, files, or APIs. We’ll outline practical strategies and fallbacks.

Common parsing scenarios (user input, third-party API responses, CSV imports)

We encounter dates from web forms in localized formats, third-party APIs returning ISO or custom strings, and CSV files containing inconsistent patterns. Each source has its own quirks: missing time zones, truncated values, or ambiguous orderings.

Strategies for identifying incoming date formats

We start by inspecting sample payloads and metadata. If possible, we prefer providers that specify formats explicitly. When not specified, we detect patterns (presence of “T” for ISO, slashes vs dashes, numeric lengths) and log samples so we can build robust parsers.

Using parsing functions or expressions to convert strings to usable dates

We convert strings to date objects using Make.com’s expression tools or module fields that accept parsing patterns. The typical flow is: detect the format, use a parse expression to produce a normalized date or timestamp, and verify the result before persisting or using in logic.

Handling ambiguous dates (locale differences like MM/DD vs DD/MM)

For ambiguous formats, we either require an explicit format from the source, infer locale from other fields, or ask the user to pick a format. If that’s not possible, we implement validation rules (e.g., reject dates where day>12 if MM/DD expected) and provide fallbacks or error handling.

Fallbacks and validation for failed parses

We build fallbacks: try multiple parse patterns in order, record parse failures for manual review, and fail-safe by defaulting to UTC now or rejecting the record when correctness matters. We also surface parsing errors into logs or notifications to prevent silent data corruption.

Formatting Dates: Presenting Dates for Outputs

Formatting turns internal dates into human- or API-friendly strings. We’ll cover common tokens and practical examples.

Formatting for display vs formatting for API consumers

We distinguish user-facing formats (readable, localized) from API formats (often ISO 8601 or epoch). For displays we use friendly strings and localized month/day names; for APIs we stick to the documented format to avoid breaking integrations.

Common format tokens and patterns (ISO, RFC, custom patterns)

We rely on patterns like ISO 8601 (YYYY-MM-DDTHH:mm:ssZ), RFC variants, and custom tokens such as YYYY, MM, DD, HH, mm, ss. Knowing these tokens helps us construct formats like YYYY-MM-DD or “MMMM D, YYYY HH:mm” for readability.

Using format functions to create readable timestamps for emails, reports, and logs

We use formatting expressions to generate emails like “March 5, 2025 14:30” or concise logs like “2025-03-05 14:30:00 UTC”. Consistent formatting in logs and reports makes troubleshooting and audit trails much easier.

Localized formats and formatting month/day names

When presenting dates to users, we localize both numeric order and textual elements (month names, weekday names). We store the canonical time in UTC and format according to the user’s locale at render time to avoid confusion.

Examples: timestamp to ‘YYYY-MM-DD’, human-readable ‘March 5, 2025 14:30’

We frequently convert epoch timestamps to canonical forms like YYYY-MM-DD for databases, and to user-friendly strings like “March 5, 2025 14:30” for emails. The pattern is: convert epoch → date object → format string appropriate to the consumer.

Time Zone Concepts and Handling

Time zones are a primary source of complexity. We’ll summarize key concepts and practical handling patterns.

Understanding UTC vs local time and why it matters in automations

UTC is a stable global baseline that avoids daylight saving shifts. Local time varies by region and can change with DST. For automations, mixing local times without clear conversion rules leads to missed schedules or duplicate actions, so we favor explicit handling.

Strategies for storing normalized UTC times and converting on output

We store dates in UTC internally and convert to local time only when presenting to users or calling APIs that require local times. This approach simplifies comparisons and duration calculations while preserving user-facing clarity.

How to convert between time zones inside Make.com scenarios

We convert by interpreting the original date’s time zone (or assuming UTC when unspecified), then applying time zone offset rules to produce a target zone value. We also explicitly tag outputs with time zone identifiers so recipients know the context.

Handling daylight saving time changes and edge cases

We account for DST by using timezone-aware conversions rather than fixed-hour offsets. For clocks that jump forward or back, we build checks for invalid or duplicated local times and test scenarios around DST boundaries to ensure scheduled jobs still behave correctly.

Best practices for user-facing schedules across multiple time zones

We present times in the user’s local zone, store UTC, show the zone label (e.g., PST, UTC), and let users set preferred zones. For recurring events, we confirm whether recurrences are anchored to local wall time or absolute UTC instants and document the behavior.

Relative Time Calculations and Duration Arithmetic

We’ll cover how we add, subtract, and compare times, plus common pitfalls with month/year arithmetic.

Adding and subtracting time units (seconds, minutes, hours, days, months, years)

We use arithmetic functions to add or subtract seconds, minutes, hours, days, months, and years from date objects. For short durations (seconds–days) this is straightforward; for months and years we keep in mind varying month lengths and leap years.

Calculating differences between two dates (durations, age, elapsed time)

We compute differences to get durations in units (seconds, minutes, days) for timeouts, age calculations, or SLA measurements. We normalize both dates to the same zone and representation before computing differences to avoid drift.

Common patterns: next occurrence, deadline reminders, expiry checks

We use arithmetic to compute the next occurrence of events, send reminders days before deadlines, and check expiry by comparing now to expiry timestamps. Those patterns often combine timezone conversion with relative arithmetic.

Using durations for scheduling retries and timeouts

We implement exponential backoff, fixed retry intervals, and timeouts using duration arithmetic. We store retry counters and compute next try times as base + (attempts × interval) to ensure predictable behavior across runs.

Pitfalls with months and years due to varying lengths

We avoid assuming fixed-length months or years. When adding months, we define rules for end-of-month behavior (e.g., add one month to January 31 → February 28/29 or last day of February) and document the chosen rule to prevent surprises.

Working with Variables, Data Stores, and Bundles

Dates flow through our scenarios via variables, data stores, and bundles. We’ll explain patterns for persistence and mapping.

Setting and persisting date/time values in scenario variables

We store intermediate date values in scenario variables for reuse across a single run. For persistence across runs, we write canonical UTC timestamps to data stores or external databases, ensuring subsequent runs see consistent values.

Passing date values between modules and mapping considerations

When mapping date fields between modules, we ensure both source and target formats align. If a target expects ISO strings but we have an epoch, we convert before mapping. We also preserve timezone metadata when necessary.

Using data stores or aggregator modules to retain timestamps across runs

We use Make.com data stores or external storage to hold last-run timestamps, rate-limit windows, and event logs. Persisting UTC timestamps makes it easy to resume processing and compute deltas when scenarios restart.

Working with bundles/arrays that contain multiple date fields

When handling arrays of records with date fields, we iterate or map and normalize each date consistently. We validate formats, deduplicate by timestamp when necessary, and handle partial failures without dropping whole bundles.

Serializing dates for JSON payloads and API compatibility

We serialize dates to the API’s expected format (ISO, epoch, or custom string), avoid embedding ambiguous local times without zone info, and ensure JSON payloads include clearly formatted timestamps so downstream systems parse them reliably.

Scheduling, Triggers, and Scenario Execution Times

How we schedule and trigger scenarios determines reliability. We’ll cover strategies for dynamic scheduling and calendar awareness.

Differences between scheduled triggers vs event-based triggers

Scheduled triggers run at fixed intervals or cron-like patterns and are ideal for polling or periodic tasks. Event-based triggers respond to incoming webhooks or data changes and are often lower latency. We choose the one that fits timeliness and cost constraints.

Using date functions to compute next run and dynamic scheduling

We compute next-run times dynamically by adding intervals to the last-run timestamp or by calculating the next business day. These computed dates can feed modules that schedule follow-up runs or set delays within scenarios.

Creating calendar-aware automations (business days, skip weekends, holiday lists)

We implement business-day calculations by checking weekday values and applying holiday lists. For complex calendars we store holiday tables and use conditional loops to skip to the next valid day, ensuring actions don’t run on weekends or declared holidays.

Throttling and backoff strategies using time functions

We use relative time arithmetic to implement throttling and backoff: compute the next allowed attempt, check against the current time, and schedule retries accordingly. This helps align with API rate limits and reduces transient failures.

Aligning scenario execution with external systems’ rate limits and windows

We tune schedules to match external windows (business hours, maintenance windows) and respect per-minute or per-day rate limits by batching or delaying requests. Using stored timestamps and counters helps enforce these limits consistently.

Formatting for APIs and Third-Party Integrations

Interacting with external systems requires attention to format and timezone expectations.

Common API date/time expectations (ISO 8601, epoch seconds, custom formats)

Many APIs expect ISO 8601 strings or epoch seconds, but some accept custom formats. We always check the provider’s docs and match their expectations exactly, including timezone suffixes if required.

How to prepare dates for sending to CRM, calendar, or payment APIs

We map our internal UTC timestamp to the target format, include timezone parameters if the API supports them, and ensure recurring-event semantics (local vs absolute time) match the API’s model. We also test edge cases like end-of-month behaviors.

Dealing with timezone parameters required by some APIs

When APIs require a timezone parameter, we pass a named timezone (e.g., Europe/Berlin) or an offset as specified, and make sure the timestamp we send corresponds correctly. Consistency between the timestamp and timezone parameter avoids mismatches.

Ensuring consistency when syncing two systems with different date conventions

We pick a canonical internal representation (UTC) and transform both sides during sync. We log mappings and perform round-trip tests to ensure a date converted from system A to B and back remains consistent.

Testing data exchange to avoid timezone-related bugs

We test integrations around DST transitions, leap days, and end-of-month cases. Test records with explicit time zones and extreme offsets help uncover hidden bugs before production runs.

Conclusion

We’ll summarize the main principles and give practical next steps for getting reliable date/time behavior in Make.com.

Summary of key principles for reliable date/time handling in Make.com

We rely on three core principles: normalize internally (use UTC or canonical timestamps), convert explicitly (don’t assume implicit time zones), and validate/format for the consumer. Applying these avoids most timing bugs and ambiguity.

Final best practices: standardize on UTC internally, validate inputs, test edge cases

We standardize on UTC for storage and comparisons, validate incoming formats and fall back safely, and test edge cases around DST, month boundaries, and ambiguous input formats. Documenting assumptions makes scenarios easier to maintain.

Next steps for readers: apply patterns, experiment with snippets, consult docs

We encourage practicing with small scenarios: parse a few example strings, store a UTC timestamp, and format it for different locales. Experimentation reveals edge cases quickly and builds confidence in real-world automations.

Resources for further learning: official docs, video tutorials, community forums

We recommend continuing to learn by reading official documentation, watching practical tutorials, and engaging with community forums to see how others solve tricky date/time problems. Consistent practice is the fastest path to mastering Make.com’s date and time functions.

If you want to implement Chat and Voice Agents into your business to reduce missed calls, book more appointments, save time, and make more revenue, book a discovery call here: https://brand.eliteaienterprises.com/widget/bookings/elite-ai-30-min-demo-call