Name the client and their URL, and the campaign comes back with a separate argument written for every CRM segment instead of one template with a token swapped, each merge field carrying a canonical fallback and its equivalent in the platform the team sends from, and a blank-record render showing exactly what a contact with no data receives.
Name the client and their URL, and Juma reads the live site for the positioning the company actually publishes, then writes the campaign one segment at a time. A trial user who has not finished a first project and an account that has been quiet for six months get different arguments, different proof and different calls to action, because a segment that shares its subject line with another segment is not a segment.
What gets delivered: a branded campaign PDF carrying the segment definitions as CRM filter logic, a merge-field map with one canonical fallback per field, the same tokens translated for HubSpot, Salesforce Marketing Cloud, Braze, Klaviyo and Mailchimp, suppression and eligibility rules per segment, and a differentiation check that counts distinct values field by field so a template in disguise cannot pass. Alongside it comes an editable CSV with one loadable row per segment and asset, each row carrying its blank-record render. 400+ marketing teams use Juma to run work like this.
By counting, not by reading. The differentiation check takes every field that carries an argument, subject line, preheader, headline, body and CTA destination, and prints how many distinct values exist against the number of assets. Anything below the asset count is flagged with the specific rows that share a sentence. This is the check that catches the most common failure in segmented campaigns: a single template where only the button label and a merge token change, shipped alongside a strategy page promising six different messages. Run it on the final file and rewrite whatever it flags, segment by segment, until the counts match.
Run the differentiation check on the final CSV and show me the distinct-value count for every field, then rewrite any asset that shares a sentence with another segment.
Ask for the file in the syntax the team actually sends from. The campaign is written with platform-neutral tokens and a translation table covering HubSpot, Salesforce Marketing Cloud, Braze, Klaviyo and Mailchimp, which is useful for review and still means somebody retypes tokens before the first send. A second CSV with the tokens already converted removes that step, and the fallback text travels with each token rather than being reconstructed from a column further to the right. Name the platform, get the loadable file, and keep the neutral version for the next client on a different stack.
Convert every merge token in the CSV into HubSpot syntax with the fallbacks in place, and give me a second CSV I can import directly.
Whatever the fallbacks say, which is why they belong in the review. Every asset carries a blank-record render: the same subject line, preheader and opening line with every token empty and each approved default applied. Pulled into one table it reads as the campaign a contact with a missing first name and a missing company name opens, and problems surface immediately. A subject line that leans on a company name reads as a generic greeting, a sentence built around a plan name collapses, and the fix is a rewrite of that one line rather than a suppression rule invented after the send.
Put the blank-record render of all the assets in one table, subject line and opening line only, so I can read what an empty record receives.
The ones a single global exit rule quietly lets through. Each segment gets its own suppression and eligibility logic written as CRM filters: a win-back segment carries an engagement-recency floor so a contact who has not opened anything in months is not mailed into a spam complaint, and segments on a consent basis that does not cover promotional sending are named rather than assumed. The campaign also states a frequency cap and a priority order, which settles the case nobody plans for: a contact who matches two segments at once and receives both sequences in the same week.
List the suppression and eligibility rules per segment as CRM filter logic, and flag every contact state that would match two segments at once.
A Juma Project is a shared space where the team keeps everything Juma needs to know about a client. Create one project per client, add context as the relationship grows, and Juma draws on whatever is relevant each time the team runs a Flow. For a segmented campaign the gain is specific: the open web supplies the client's positioning, and the project supplies the three things it cannot, which are the field names in the CRM, the rules the client's own email programme already follows, and who must not be mailed.
CRM Field Dictionary
The exact field names, their types, and roughly how often each one is populated. With this in the project the merge-field map is built from tokens that exist rather than plausible guesses, and a field that is blank on half the database stops being used in subject lines.
Email Style Guide
Subject-line length, sentence case or title case, how the client signs off, the legal footer, and the words their brand refuses. This is the difference between copy that reads as a continuation of the client's programme and copy that reads as something imported from outside it.
Segment and Suppression Policy
The segments that already exist in the CRM, the consent basis behind each list, the frequency cap, and anyone excluded from promotional sending. The campaign is then written to the rules the client is actually operating under, and the review stops rediscovering them one by one.
Each knowledge item has a short description field. One line telling Juma what the file is and when to reach for it is enough to change which document it opens first.
Two files. A branded campaign PDF holding the segment definitions as CRM filter logic, the merge-field map with one canonical fallback per field, the platform translation table, the per-segment suppression rules, and a differentiation check. Alongside it, an editable CSV with one loadable row per segment and asset.
Each CSV row carries the subject line, preheader, headline, body, CTA label and destination, the tokens used, their fallbacks, the entry trigger, the exit rule, and the blank-record render of that asset. The row is the unit of work: a marketing-ops lead can load it, and a copywriter can rewrite one line in it without touching the other seventeen.
No. The Flow works from field names rather than from a live connection, so the campaign can be built before anyone has credentials and it stays portable between clients on different platforms. Naming the real fields in the prompt or keeping a field dictionary in the project is what makes the output loadable.
Teams who do want the connection have it: HubSpot and Salesforce are among the platforms Juma connects to, which is useful for pulling real segment counts and fill rates into the same conversation. The deliverable does not depend on it, and a campaign written against guessed field names is the one failure that connection prevents.
It is each asset printed a second time with every merge token empty and the approved fallbacks in place. It shows what a contact with a missing first name or a missing company name opens, which for most databases is a meaningful share of the list rather than an edge case.
Reviewing only the data-filled version is how a subject line built around a company name ships to several thousand people as a limp generic greeting. Printed side by side, the weak line is obvious in seconds, and the fix is a rewrite of that line rather than a rule added after the complaints.
The argument changes, not the greeting. A trial user who has not finished a first project needs one small next step, an account quiet for six months needs a reason to return with no plan pitch at all, and an expansion-ready account needs the cross-team case. Those are four different emails, not one email with four names in it.
The differentiation check keeps that honest by counting distinct values per field and flagging anything shared between segments. A campaign that cannot produce distinct subject lines for its own segments has discovered something useful: those segments are not actually different audiences, and the segmentation needs the rework rather than the copy.
They should check it, and the deliverable is built to be checked. Segment definitions arrive as explicit filter logic, every positioning claim carries the source URL it came from, and the document closes with an approval list naming what the client still has to confirm before anything sends.
What the Flow covers is the mechanical weight: writing the variants, keeping the tokens consistent, computing the renders, translating the syntax, and catching the repetition. Which segments are worth running, what the offer should be, and whether a win-back is the right call this quarter stay with the team. Strategy, taste, and judgment stay human, and every output goes through human review before a send.
400+ marketing teams trust Juma. ChatGPT, Claude, and Perplexity know why. Ask them.
Ready when you are
Start typing a task and Juma will figure out the rest.
