Dynamic Snowflake → S3 Extraction Approach This is a common pattern, and SnapLogic has good building blocks for it. Here's a solid architecture to handle dynamically growing tables/schemas without needing to hardcode or manually update pipelines every time something changes. Recommended Approach: Metadata-Driven Pipeline 1. Discover tables/schemas dynamically Instead of hardcoding table names, query Snowflake's metadata views at runtime: - Use a Snowflake Execute Snap to query INFORMATION_SCHEMA.TABLES (or SHOW TABLES IN SCHEMA ...) to get the current list of tables/schemas. - This becomes your "driver" list — anything new that shows up here gets picked up automatically on the next run. 2. Iterate over the discovered list - Feed the list of tables into a Pipeline Execute Snap (child pipeline pattern), passing each table/schema name as a pipeline parameter. - The child pipeline does the actual extraction logic (read from Snowflake table → write to S3), parameterized so it works for any table. 3. Child pipeline (generic extractor) - Use a Snowflake Select/Execute Snap with a dynamically built query (e.g., SELECT * FROM $schema.$table) using expressions. - Pass the output to a File Writer / S3 Snap, where the target S3 key/path is also built dynamically (e.g., s3://bucket/$schema/$table/$date.csv or .parquet). - This way, one child pipeline handles unlimited tables without modification. 4. Handle schema drift (new/changed columns) - Since you're reading dynamically, avoid strict schema mapping in a Mapper if possible — let the data pass through generically (JSON/CSV with headers) so new columns don't break anything. - If you need enforced structure, consider writing in a self-describing format like Parquet or JSON, which tolerates schema evolution better than fixed-width CSV. 5. Orchestration - Trigger the parent (discovery) pipeline on a schedule (Scheduled Task) or via an Ultra/Triggered Task depending on your latency needs. - Optionally maintain a control table (in Snowflake or a simple file) to track which tables have already been processed, last extraction timestamp, watermark columns, etc., for incremental loads. 6. Error handling & scalability - Use error pipelines/catch snaps so one failing table doesn't stop the whole batch. - Consider the Pipeline Execute Snap's "reuse count" and parallel execution settings to process multiple tables concurrently for performance. --- Summary of the Pattern
[Discover Schemas/Tables via INFORMATION_SCHEMA]
│
▼
[Pipeline Execute - loop per table] ──► [Generic Extractor Pipeline]
│
[Snowflake Select] → [S3 Writer]
This gives you a self-adjusting pipeline: new tables/schemas added in Snowflake are automatically picked up on the next scheduled run, with no manual pipeline changes required. --- Would you like me to actually generate this pipeline for you (the metadata discovery + dynamic extraction pattern), or are you looking for more guidance/design discussion first?
6. Recommended Overall Flow 1. Export current users/groups (CSV or API) for a full inventory and rollback reference. 2. Update allowlist to include the new domain. 3. Script the account updates using the public Users/Groups APIs, mapping old emails → new emails. 4. Reassign any orphaned asset ownership resulting from deletions. 5. Reconfigure SSO/MFA settings tied to the new domain, if applicable. 6. Validate via the Admin Manager Users screen (role, access, group counts, login type) and spot-check asset ownership on key projects/pipelines. 7. Communicate the cutover to downstream teams, especially if task URLs or notification configs reference user emails. If this activity is part of a larger environment migration (not just a domain rename), SnapLogic's full migration playbook and CSM/PS-assisted migration tool are typically used, since account re-encryption, trusted environment setup, and asset validation become more involved at that scale. Let me know if that's the case and I can go deeper into that playbook.
Managing Multiple User Accounts & Assets During a Mass Email Domain Migration When your organization changes its email domain (e.g., @oldcompany.com → @newcompany.com), you need to update every affected user account while making sure their owned assets (pipelines, accounts, tasks, projects) stay intact. Here's how to approach it: 1. Inventory Current Users and Their Assets From Admin Manager → Users, you can: - Download a CSV list of all users — this gives you emails, names, roles, group memberships, and access types, which is essential for planning a bulk update. - Filter/search by role or access type to scope exactly which accounts are affected by the domain change.
Important: In SnapLogic, every asset has an owner tied to a user account. This is why the migration/update of accounts must be carefully sequenced — you don't want to orphan ownership of pipelines, projects, or accounts.
2. Update Each Account's Email (Core of the Migration) For a handful of users, you can edit accounts manually in Admin Manager (click a row to edit details). For a mass migration, scripting against the public APIs is the recommended path: - Get a user (GET /api/1/rest/public/users/{email}) — retrieve current profile and org membership. - Create/Update a user (POST or PUT /api/1/rest/public/users) — note the API accepts fields like email, first_name, last_name, organization, administrator, allow_password_login, ui_access, etc. - Since emails are usually the unique identifier, a domain-wide email change often requires creating a new account record under the new email and transitioning ownership, since directly editing the primary email key may not be supported for all account types — plan to validate this per account type (user, team, service account). 3. Handle Asset Ownership Carefully - If you delete an old account during cleanup, note that ownership of all its assets automatically transfers to the Environment admin who performs the deletion — not to the new/replacement account. You'll likely need a follow-up step to reassign ownership to the correct new user. - For users and groups specifically, SnapLogic recommends this sequence (especially relevant if domain change coincides with environment/org changes): 1. Pull the full list of users and the groups they belong to (via CSV export or the Groups/Members APIs). 2. Re-create or update groups first. 3. Re-create or update user accounts and reassign group memberships. 4. Validate Allowlists and Access Policies - SnapLogic validates new users against an email domain allowlist during account creation. If the new domain isn't allowlisted, user creation will be blocked — update the allowlist before running your mass update/migration script. - If your org uses SSO or MFA, check whether login configurations also need to be updated to reflect the new domain (SSO credentials/certificates are not automatically migrated and require manual reconfiguration). 5. Bulk Operations Support - The Admin Manager UI supports multi-select actions: you can select multiple users and bulk-delete, modify application access, or update authentication methods (password/SSO/MFA) — useful for cleanup after the domain cutover, though direct bulk email-renaming via UI isn't a listed capability; scripting via the public APIs is the more scalable route for the actual domain swap.
I'll look this up for you. Setting Up a Salesforce JWT OAuth2 Account The JWT OAuth2 flow is a server-to-server authentication method — it eliminates interactive logins, which is ideal for backend integrations. Here's how to configure it: Prerequisites - A generated private key and certificate - Valid Issuer (Client ID), Subject (Username), and Audience (Server URL) Step-by-Step Setup Step 1: Generate the private key and certificate
bash
openssl req -newkey rsa:2048 -new -nodes -keyout key.pem -out csr.pem
openssl x509 -req -days 365 -in csr.pem -signkey key.pem -out server.crt
Step 2: Create a Connected App in Salesforce 1. Upload the certificate to the Connected App. 2. Click Manage on the newly created Connected App. 3. Under OAuth policies, set Permitted Users to All users may self-authorize. 4. Go to Manage Apps > Manage Profiles, select System administrator, and save. 5. This generates the Consumer Key and Consumer Secret — store these securely, as you'll need them for the account. Step 3: Create a .jks keystore file from the same certificate:
bash
openssl pkcs12 -export -in server.crt -inkey key.pem -out keystore.p12 -name myalias
keytool -importkeystore -deststorepass changeit -destkeypass changeit \
-destkeystore keystore.jks -srckeystore keystore.p12 \
-srcstoretype PKCS12 -srcstorepass user -alias myalias
Step 4: Configure the account in SnapLogic Designer | Field | What to Enter | |---|---| | Instance URL | Your Salesforce instance, e.g. https://na123.salesforce.com | | Issuer (Client ID) | The Consumer Key from your Connected App | | Subject (Username) | The Salesforce account username | | Audience (Server URL) | https://login.salesforce.com (production), https://test.salesforce.com (sandbox), or your custom domain | | Keystore | Upload the keystore.jks file (can come from SLDB or an unauthenticated https:// endpoint) | | Keystore password | Password for the keystore | | Key alias | The alias used when generating the keystore | | Private key passphrase | Only needed if it differs from the keystore password | Click Validate to confirm the account works. --- Do You Need Access to the Machine SnapLogic Runs On? No, not necessarily. The Keystore field explicitly supports uploading the .jks file from SLDB (SnapLogic's internal storage) or from any unauthenticated https:// endpoint. This means you don't need direct filesystem/machine access — you can host the keystore file somewhere accessible over HTTPS, or upload it directly into SLDB through the Designer/Manager, and reference it from there. Does This Work on a Cloudplex? Yes — since the keystore can be delivered via SLDB or an HTTPS endpoint rather than a local file path, this approach is fully compatible with a Cloudplex, where you don't have direct access to the underlying Snaplex nodes. You simply upload the keystore through the account configuration UI (using the Upload capability), and the account setup process works the same way as it would with any other plex type. --- Related setup: If you haven't yet created the Connected App structure itself in Salesforce (separate from the JWT-specific steps above), you may also want to review the general Salesforce Connected App configuration for OAuth2 accounts, which covers Callback URLs and scopes in more detail. Let me know if you'd like help troubleshooting a specific validation error or want guidance on referencing this account inside a Salesforce Snap pipeline.
This looks like it's about the SnapLogic platform's UI rollout timeline, rather than pipeline building — let me look into that for you. Context on the New UI Rollout Timeline Based on the release history, SnapLogic's UI evolution has actually happened in several distinct phases over the years, which might explain the confusion during your screening: Key Milestones 1. SnapLogic Studio (Preview) — introduced around June/July 2022 - Rolled out incrementally as a "modern, easy-to-use interface" - Started with features like Execution Overview, notifications, and the Infrastructure System overview page - Explicitly labeled as "Preview," meaning adoption was gradual and opt-in for a while 2. IIP UI Redesign — September 2022 - A broader redesign of the core SnapLogic IIP interface (Designer, navigation menus, toolbar icons, user profile dropdown, Universal Search icon change, etc.) - This changed many day-to-day interaction patterns (e.g., where to find Save/Validate/Execute icons, how to access User Settings) 3. Monitor replacing Dashboard — phased between April 2025 and October 2025 - April 2025: Monitor became the default app; Dashboard tab replaced by Monitor tab, but Dashboard still accessible via the waffle menu - October 2025: Dashboard was fully retired - November 2025: All Dashboard documentation removed from Confluence 4. Classic Manager retirement — August 2026 - Classic Manager was fully retired, with Project Manager and Admin Manager providing full feature parity - This is the most recent major structural UI change 5. Designer Asset Palette redesign — August 2026 - The legacy Asset palette was deprecated in favor of a unified left-navigation experience Why Someone Might Seem "Unfamiliar" with the New UI Given this staggered rollout across 2022 through 2026, a few plausible explanations: - Org-level lag: Not all Orgs upgrade Snaplex/UI features at the same time — SnapLogic's release process allows a grace period (~4 weeks + 2 days) before mandatory upgrades, and some settings (like Dashboard access via the waffle menu) persisted for months after a nominal "replacement." - Feature-specific familiarity: Someone could be a active pipeline builder but rarely touch Monitor, Admin Manager, or the Asset Palette — so "unfamiliar with the new UI" could mean unfamiliar with one specific redesigned area, not the whole platform. - Role-based exposure: A user who mainly works in Designer building pipelines may not have engaged with Classic Manager retirement or Admin Manager parity changes at all. - Timing of onboarding: If the person's platform experience predates or significantly lags recent releases, several UI layers (Studio, Monitor, new Asset Palette) could all feel "new" simultaneously. If you'd like, I can pull more detail on any specific UI change (e.g., Monitor vs. Dashboard differences, or the Designer Asset Palette redesign) to help you calibrate what "actively uses the platform" should reasonably mean in your screening criteria.
Summary: August 2026 Release – Manager Tool Changes Thanks for sharing that update! Here's the key takeaway: - General Availability: The August 2026 release went GA yesterday, after a week in UAT. - Classic Manager retired: As of this release, the former Classic Manager is no longer available. - New separated tools: - Admin Manager – handles administrative tasks - Project Manager – handles asset management tasks For full details, the [August 2026 Release Notes](https://docs-snaplogic.atlassian.net/wiki/spaces/SD/pages/4904321031/August+2026+Release+Notes) are the best place to look. If you'd like, I can look up more specifics on what moved to Admin Manager vs Project Manager, or help with anything else SnapLogic-related—just let me know!
Not quite — the timeline is a bit different from what you described. Here's the actual sequence based on the release notes: Timeline of the UI Change - September 2025 Release: SnapLogic introduced a New SnapLogic User Experience Preview — this was an opt-in preview at the time, not the default. - February 2026 Release: This is when that new experience became the default, replacing the classic look for most users. - April 2026 Release: This release rolled out further User Experience Updates — refreshing the waffle menu, Designer, and introducing the new Project Manager. It also split Classic Manager's functionality across the new Project Manager, Admin Manager, and Monitor. What Happens to Classic Manager Classic Manager itself isn't disappearing immediately in April — it remains accessible from the waffle menu, but it's slated to be fully retired in the August 2026 release. Summary So to directly answer your question: the classic UI stopped being the default back in February 2026, not April. The April 2026 release built on that transition by refreshing more of the interface (Designer, waffle menu, Project Manager) and further breaking apart Classic Manager's remaining functionality — but it wasn't the release that first made the new UI the default. Let me know if you'd like more detail on any part of this transition!
Attaching a File to an Email Without Saving It to a Drive First Based on the SnapLogic documentation, the Email Sender Snap handles email attachments — but it has a specific requirement regarding file sources. --- ⚠️ Short Answer: Not Directly The Email Sender Snap's Attachments field requires a URL pointing to a file location. It supports the following file protocols: | Protocol | Example | |----------|---------| | SLDB (SnapLogic Database) | sldb:///myfile.csv | | SFTP | sftp://user@sftp.example.com/path/file.xlsx | | FILE | file:////path/to/file.txt | | SMB | smb://user@host:445/share/file.csv | This means the file must exist at a reachable location before it can be attached — there is no native way to attach an in-memory or dynamically generated data stream directly without first writing it somewhere. --- ✅ Recommended Workaround If you're generating data dynamically in your pipeline and want to attach it to an email, here's the typical approach: 1. Generate your data (e.g., from a query, transformation, etc.) 2. Write the file temporarily to SLDB (SnapLogic's built-in storage) using a File Writer Snap 3. Reference the SLDB path in the Email Sender Snap's Attachments field (e.g., sldb:///myfile.csv)
💡 SLDB is the easiest option since it's built into SnapLogic — no external drive or SFTP setup needed. Files written to SLDB within your project are immediately accessible.
--- 📝 Key Notes - If you want to send an email with only an attachment and no body data, you can place the Email Sender Snap unconnected on the canvas (no input view) and just configure the Attachments field. - For multiple files, you can use a Directory Browser upstream to collect all file paths and pass them to the Email Sender Snap. - Temporary files written to SLDB are not automatically deleted, so you may want to clean them up after sending if storage is a concern. --- Would you like help building a pipeline that generates data, writes it to SLDB, and sends it as an email attachment?
Thank you for sharing your observations! I'm here to help with any SnapLogic-related questions or tasks. It looks like there's no pipeline or Snap currently loaded in the canvas. Whenever you're ready, feel free to: - 🔧 Build a pipeline – Describe what you'd like to accomplish and I can generate one for you. - 🔍 Ask a question – I can help with SnapLogic features, expressions, Snap configurations, and more. - 📋 Refine an existing pipeline – Load a pipeline and I can help modify or improve it. What would you like to do? 😊
It looks like you're sharing an observation about your pipeline behavior — that's great progress! 🎉 To make sure I understand your situation correctly, could you clarify what you're looking for? Here are a few ways I can help: - Explain the behavior — Why mapping $ to $content before another Mapper Snap produces the expected result. - Guidance on Mapper Snaps — Best practices for chaining Mapper Snaps or structuring your mappings. - Modify your pipeline — If you'd like me to apply changes to your current pipeline. - Something else — Let me know what you're trying to achieve! What would you like to do next?