undefined

**Create this file using the Write tool immediately after loading this Skill.**

---

Primary: "What's the best architecture for integrating Salesforce with SQL Server in 2025?"

Sub-Questions:
1. What are Salesforce's current integration capabilities and APIs (2025)?
2. What are SQL Server's integration patterns and best practices?
3. What middleware or integration platforms are commonly used?
4. What security and compliance considerations matter?
5. What scalability and performance factors should influence choice?

Sub-Q1: Salesforce Integration Capabilities
  - site:salesforce.com "API" "integration" "2025"
  - "Salesforce REST API" "rate limits" after:2024
  - "Salesforce Bulk API 2.0" "best practices"
  - filetype:pdf "Salesforce integration guide" 2025
  - "Salesforce API" "breaking changes" after:2024

Official Docs: site:docs.{vendor}.com "{topic}" "architecture patterns" OR "design patterns"
Best Practices: "{topic}" "best practices" "production" after:2024
Comparisons: "{topic}" vs "{alternative}" "comparison" "pros cons"
Limitations: "{topic}" "limitations" OR "drawbacks" OR "challenges"
Recent Updates: site:{vendor}.com "{topic}" "updates" OR "changes" after:2024

Official Docs: site:docs.{framework}.com "{feature}" "guide" OR "documentation"
Community: site:stackoverflow.com "{framework}" "{feature}" "how to"
Real-World: "{framework}" "{feature}" "production" OR "case study" after:2024
Performance: "{framework}" "performance" OR "benchmarks" OR "optimization"
Ecosystem: "{framework}" "ecosystem" OR "plugins" OR "extensions" 2025

Industry Analysis: "{topic}" "market analysis" OR "industry trends" 2024 2025
Vendor Comparison: "{vendor A}" vs "{vendor B}" "comparison" "review"
ROI/Benefits: "{solution}" "ROI" OR "benefits" OR "value proposition"
Implementation: "{solution}" "implementation guide" OR "getting started"
Case Studies: "{solution}" "case study" OR "customer success" after:2024

Fundamentals: "{topic}" "introduction" OR "beginner guide" OR "explained"
Advanced: "{topic}" "advanced" OR "deep dive" OR "internals"
Tutorials: "{topic}" "tutorial" OR "step by step" after:2024
Common Mistakes: "{topic}" "common mistakes" OR "anti-patterns" OR "pitfalls"
Resources: "{topic}" "learning resources" OR "courses" OR "books" 2025

Standards: "{topic}" "{standard}" "compliance" (e.g., "GDPR", "SOC2", "HIPAA")
Security: "{topic}" "security" "best practices" OR "vulnerabilities" after:2024
Official Guidance: site:{regulator}.gov "{topic}" "guidance" OR "requirements"
Audit: "{topic}" "audit" OR "checklist" OR "certification"
Tools: "{topic}" "{compliance}" "tools" OR "automation" 2025

Benchmarks: "{topic}" "benchmark" OR "performance" "comparison" after:2024
Bottlenecks: "{topic}" "bottleneck" OR "slow" OR "performance issues"
Optimization: "{topic}" "optimization" OR "tuning" OR "best practices"
Monitoring: "{topic}" "monitoring" OR "observability" OR "metrics"
Scaling: "{topic}" "scalability" OR "high traffic" OR "production scale"

undefined

# Step 3: Execute ALL queries in batch SIMULTANEOUSLY in single message
# Example: If batch = [q1, q2, q3, q4, q5], call:
#   WebSearch(q1)
#   WebSearch(q2)
#   WebSearch(q3)
#   WebSearch(q4)
#   WebSearch(q5)
# ALL FIVE in the SAME message as parallel tool uses

results = execute_parallel_batch(batch)
process_batch_results(results)  # Collect sources immediately

**Why This Matters**:
- **Sequential Execution**: 25 queries × 1s each = 25s total
- **Batched Execution** (5 per batch): 5 batches × 1s = 5s total
- **Speedup: 3-5x faster** for Phase 2

**Batch Size Guidance**:
- **Simple queries** (keywords only): Use batch_size=10
- **Complex queries** (advanced operators, multiple site: filters): Use batch_size=5
- **Re-queries** in iteration 2+: Use batch_size=3-5

**Example Batched Execution**:

undefined

undefined

undefined

Text with claim from [OpenAI: GPT-4](https://url "GPT-4 Technical Report (OpenAI, 2023-03-14)") and [Anthropic: Claude](https://url2 "Introducing Claude (Anthropic, 2023-03-14)"). Multiple sources: [Google DeepMind: Gemini](https://url3 "Gemini Model (Google DeepMind, 2023-12-06)"), [Meta: LLaMA](https://url4 "LLaMA Paper (Meta AI, 2023-02-24)").

[Organization: Topic](full-URL "Full Title (Publisher, YYYY-MM-DD)")

undefined

**Why grouped References section?**
- Provides organized list view by source type
- Easy to scan authoritative vs. community sources
- Shows evidence diversity at a glance
- Copy-paste for further research

**Category Guidance**:
- **Official Documentation**: Vendor docs, API references, official guides
- **Blog Posts & Articles**: Company engineering blogs, Medium, Dev.to, technical articles
- **Academic Papers**: arXiv, research papers, conference proceedings, whitepapers
- **Community Resources**: Stack Overflow, GitHub discussions, Reddit, forums

**Title Format in Quotes**:
- `"Full Title (Publisher, YYYY-MM-DD)"`
- Keep title concise but descriptive (< 80 chars if possible)
- Always include publisher and date for credibility

**Hover Behavior**:
Most markdown viewers (GitHub, VS Code, Obsidian, GitLab) show the title as a tooltip when hovering over the citation.

**Click Behavior**:
Clicking the descriptive name opens the URL directly in browser.

**Example Inline Usage**:
```markdown
Salesforce provides three primary API types according to [Salesforce: API Docs](https://developer.salesforce.com/docs/apis "Salesforce API Documentation (Salesforce, 2025-01-15)"): REST API for standard operations, [Salesforce: Bulk API 2.0](https://developer.salesforce.com/docs/atlas.en-us.api_asynch.meta/api_asynch/ "Bulk API 2.0 Guide (Salesforce, 2024-11-20)") for large data volumes (>10k records), and [Salesforce: Streaming API](https://developer.salesforce.com/docs/atlas.en-us.api_streaming.meta/api_streaming/ "Streaming API Guide (Salesforce, 2024-10-05)") for real-time updates. Recent 2025 updates introduced enhanced rate limiting (100k requests/24hrs for Enterprise) and improved error handling as noted in [Salesforce Blog: API Updates](https://developer.salesforce.com/blogs/2025/01/api-updates "API Error Handling Improvements (Salesforce Blog, 2025-01-10)").

**Compatibility**: Works in GitHub, VS Code (preview), Obsidian, GitLab, all markdown viewers

undefined

**Length Guidance**:
- Executive Summary: 150-200 words
- Each Finding section: 300-400 words (opening + narrative + insights)
- Synthesis: 200-250 words
- Recommendations: 3 Critical + 3-4 Important + 2-3 Optional with detailed rationale
- **Total Target**: 250-350 lines

**Requirements**:
- Executive Summary: Scannable in <30 seconds, tells complete story
- Findings: Each section has 2-4 narrative paragraphs PLUS 3-5 Key Insights bullets
- Narrative paragraphs explain concepts, show evidence, connect ideas
- Key Insights are distilled actionable takeaways
- Synthesis: Shows big picture, notes consensus (with source counts), explores contradictions
- Recommendations: Detailed rationale for each (not just bullet point + citation)
- Sources: MUST include full URLs with title, author/org, date

**What NOT to Include** (token waste):
- ❌ Evidence tables with numeric scores (0-10 ratings)
- ❌ Repository-specific details ("Main Thread Log", "CARE quality score")
- ❌ Separate Pros/Cons sections (integrate into Recommendations)
- ❌ Verbose iteration logs or detailed methodology steps

gaps = []
completeness_score = 100

**Re-Query Decision Logic**:
```python
iteration_count = 1
completeness_score, gaps = validate_completeness()

for gap in gaps:
    if "citations" in gap:
        # Need more sources for specific sub-question
        requery_list.append(f"'{sub_question_topic}' 'detailed guide' OR 'comprehensive overview'")

    elif "contradictions" in gap:
        # Need to explore downsides/criticisms
        requery_list.append(f"'{topic}' 'criticism' OR 'limitations' OR 'downsides'")
        requery_list.append(f"'{topic}' 'vs' 'alternative' 'when not to use'")

    elif "authoritative" in gap:
        # Need more official sources
        requery_list.append(f"site:docs.{vendor}.com '{topic}' 'official'")
        requery_list.append(f"site:{vendor}.com '{topic}' 'documentation'")

    elif "recent" in gap:
        # Need more recent sources
        requery_list.append(f"'{topic}' 'updates' OR 'changes' after:2024")
        requery_list.append(f"'{topic}' '2025' OR '2024' 'latest'")

# Execute re-queries in parallel batch (1-5 queries)
# Use smaller batch size for re-queries since they're targeted
requery_batch = requery_list[:5]  # Up to 5 re-queries

# Execute ALL re-queries in batch SIMULTANEOUSLY in single message
# Example: If requery_batch = [rq1, rq2, rq3], call:
#   WebSearch(rq1)
#   WebSearch(rq2)
#   WebSearch(rq3)
# ALL THREE in the SAME message as parallel tool uses
execute_parallel_batch(requery_batch)
iteration_count += 1

# Update findings incrementally
append_iteration_findings()
completeness_score, gaps = validate_completeness()

**Iteration Update Pattern**:
When adding findings from later iterations, append to existing sections:

```markdown

**When to Stop Iterating**:
- 🔴 **MANDATORY**: Minimum 2 iterations (iteration_count >= 2)
- ✅ Completeness score ≥ 85%
- ✅ All sub-questions have 3+ citations
- ✅ Contradictions section populated (or explicitly noted as "None identified")
- ✅ 50%+ authoritative sources, 30%+ recent sources
- ✅ 3+ Critical recommendations
- ⏱️ OR iteration_count > 5 (max iterations reached)

**Stop only if**: (iteration_count >= 2 AND completeness >= 85%) OR iteration_count > 5

**If Max Iterations Reached Without 85%**:
Add explicit Research Gaps section:
```markdown

undefined

Sub-Q1: Salesforce integration capabilities (2025)?
Sub-Q2: SQL Server integration patterns?
Sub-Q3: Middleware options?
Sub-Q4: Security considerations?
Sub-Q5: Scalability factors?

Generated 25 queries across 5 sub-questions

Batch 1 (5 queries - executed in parallel):
  WebSearch("site:salesforce.com 'API' 'integration' '2025'")
  WebSearch("'Salesforce REST API' 'rate limits' after:2024")
  WebSearch("'Salesforce Bulk API 2.0' 'best practices'")
  WebSearch("filetype:pdf 'Salesforce integration guide' 2025")
  WebSearch("'Salesforce API' 'breaking changes' after:2024")
→ Batch completes in ~1s, 5 results returned

Batch 2 (5 queries - executed in parallel):
  WebSearch("'SQL Server ETL' 'best practices' 'real-time'")
  WebSearch("site:docs.microsoft.com 'SQL Server' 'integration'")
  WebSearch("'SQL Server Always On' 'high availability'")
  WebSearch("'SQL Server CDC' 'change data capture'")
  WebSearch("'SQL Server linked servers' 'performance'")
→ Batch completes in ~1s, 5 results returned

Batch 3-5 (15 more queries across 3 batches):
  ... (middleware, security, scalability queries)
→ Each batch completes in ~1s

Execution Time:
- 5 batches × ~1s each = ~5s total
- Sequential would be: 25 queries × 1s = 25s
- Speedup: 5x faster

18 sources identified
12 ranked as authoritative (credibility ≥ 8)
3 contradictions (real-time vs batch approaches)

[1] Salesforce API Guide (Cred: 10, Fresh: 10, Rel: 10, Overall: 10.0)
[2] MuleSoft Patterns (Cred: 9, Fresh: 8, Rel: 9, Overall: 8.9)

Executive Summary: 2 paragraphs
Findings: 5 sub-sections with 28 citations
Recommendations: 3 critical, 4 important, 2 enhancements

Iteration 1: Identified gap in disaster recovery
Iteration 2: Re-queried "Salesforce SQL backup strategies"
Iteration 3: Completeness 92% → finalized

1. Scalability characteristics for e-commerce?
2. Team size and DevOps implications?
3. Transaction patterns differences?
4. Deployment complexity trade-offs?
5. Real-world e-commerce case studies?

"microservices e-commerce" "scalability" after:2024
"monolith vs microservices" "team size" "best practices"
site:aws.amazon.com "e-commerce architecture" "patterns"

15 sources (10 authoritative)
Consensus: Team size <20 → monolith, >50 → microservices
Contradiction: Database approach (shared vs distributed)