Forem: PRANAV BHARTI

What You Actually Learn in the Salesforce Admin Beginner Trail

PRANAV BHARTI — Mon, 13 Apr 2026 15:33:20 +0000

If you want to start learning Salesforce, the Admin Beginner Trail is one of the most practical ways to build a strong foundation. This post breaks down exactly what you’ll learn and how those concepts translate into a real application.

❓ Why Salesforce?

Salesforce is a CRM (Customer Relationship Management) platform used by companies to manage customers, sales, and operations in one place.

What makes it useful:

Low-code / No-code → You can build applications without heavy programming
Widely used → Many companies rely on Salesforce
Automation-focused → Reduces manual work
Scalable → Works for small teams as well as large organizations
Strong ecosystem (AppExchange) → Extend features easily

👉 In simple terms: You can build business applications faster with less coding.

🧱 1. Data Modeling (How Data is Organized)

In Salesforce, everything is stored in Objects (like tables in a database).

What you learn:

Difference between Standard Objects (already available) and Custom Objects (created by you)
Adding Fields (like columns)
Connecting data using:
- Lookup Relationship (loose connection)
- Master-Detail Relationship (strong connection)

👉 Simple idea: You learn how to organize and connect data properly.

📦 2. Data Management (Handling Data)

You also learn how to work with actual data:

Import/export data using:
- Data Import Wizard
- Data Loader
Maintain data quality using:
- Validation Rules (prevent wrong data)
- Duplicate Management
Understand who owns and can access records

👉 Simple idea: Keep data clean, correct, and well-managed.

🔐 3. Security & Access Control (Who Can See What)

Not everyone should see everything. Salesforce provides control over this.

You learn:

Org-Wide Defaults (OWD) → Base level access
Role Hierarchy → Access based on position
Profiles & Permission Sets → User-level permissions
Field-Level Security → Control specific fields

⚙️ 4. Automation (Reducing Manual Work)

Salesforce can automate repetitive tasks.

You learn:

Workflow Rules
Process Builder
Flows

Examples:

Sending automatic emails
Updating fields automatically
Creating tasks without manual effort

👉 Simple idea: Let the system do repetitive work for you.

🎨 5. UI Customization (Making It Easy to Use)

You can control how Salesforce looks for users.

You learn:

Page Layouts → What fields are visible
Lightning App Builder → Design pages visually
Customizing:
- Record pages
- Home pages
- App pages

👉 Simple idea: Make the system user-friendly.

📊 6. Reports & Dashboards (Understanding Data)

Salesforce helps you analyze data easily.

You learn:

Creating Reports
Applying filters and grouping
Building Dashboards for visual insights

🌐 7. Ecosystem (AppExchange)

Salesforce has a marketplace called AppExchange.

You learn:

Installing apps
Extending system functionality

👉 Simple idea: Add new features without building everything from scratch.

🛠️ Hands-On Work (Most Important Part)

This trail includes hands-on assignments for every concept.

You actually practice:

Creating objects and relationships
Building automations
Setting up security
Creating reports and dashboards

👉 Simple idea: You don’t just learn, you apply everything.

🚀 Project: MEMS (Membership & Event Management System)

To apply all concepts, I built a MEMS system using only Salesforce declarative tools (no external coding).

Application Structure (Tabs Created)

The system includes the following modules (as seen in the navigation):

Memberships
Events
Sessions
Registrations
Invoices
Reports
Dashboards
Approval Requests

👉 This reflects a complete real-world business application structure.

What I Built:

📌 Data Model (Objects & Relationships)

Contact → Stores user/member details
Membership → Linked to Contact
Event → Stores event details
Session → Linked to Event
Registration → Links Contact to Event
Invoice → Linked to Registration and Membership

Relationships:

Contact ↔ Registration
Event ↔ Registration
Event ↔ Session
Contact ↔ Membership
Registration ↔ Invoice
Membership ↔ Invoice

⚙️ Automation

Registration confirmation emails
Basic process automation using Workflow / Flows
Approval flow for certain actions via Approval Requests

🔐 Security

Role-based access control
Controlled visibility using profiles and permissions

📊 Analytics

Reports for:
- Event participation
- Membership tracking
- Revenue (Invoices)
Dashboards for visual insights

👉 Important: This system was built entirely using Salesforce declarative features like Objects, Flows, Reports, and App Builder.

StyleGuard: Keep Your UI Consistent Without Slowing Down Development

PRANAV BHARTI — Tue, 24 Mar 2026 07:04:24 +0000

Your product might work perfectly.
But does it look consistent everywhere?

A mismatched button here.
Wrong spacing there.
Different colors across pages.

These small inconsistencies quietly damage user trust and brand identity.

That’s where StyleGuard comes in.

🎯 What Is StyleGuard?

StyleGuard is a CLI tool and Node.js library that validates your frontend code against your design system or style guide.

It automatically checks your HTML/CSS for style violations - before they reach production.

Think of it as a quality gate for your UI consistency.

🚨 Why UI Consistency Matters

1. It Builds Strong Brand Identity

Your design system is your visual language.

Inconsistent styles lead to:

Confusion
Reduced trust
Poor user experience

Consistency makes your product feel professional and reliable.

2. It Reduces Design-Development Gaps

Designers define rules.
Developers implement features.

But without enforcement:

Styles drift over time
Guidelines get ignored
Reviews become subjective

StyleGuard bridges this gap with automated validation.

3. It Saves Time in Code Reviews

Manual style checks are:

Time-consuming
Error-prone
Hard to scale

StyleGuard catches issues instantly, so your team can focus on logic - not pixels.

4. It Scales With Your Product

As your codebase grows:

More contributors join
More components get added
More chances for inconsistency

StyleGuard ensures your UI stays aligned at scale.

🔍 What Does StyleGuard Check?

StyleGuard validates your code across key design system areas:

🎨 Colors → Matches approved palette
📏 Spacing → Enforces margin, padding, gaps
🔤 Typography → Font size, weight, line height
🧩 Components → Style rules for buttons, cards

It ensures your UI follows defined design tokens and guidelines.

⚙️ How Does It Work?

Install

npm install -g @elastikteams/styleguard

Run validation

styleguard validate -s ./tokens.json -p ./src

You can also:

Generate HTML reports
Fail builds based on error thresholds
Integrate into CI/CD pipelines

StyleGuard fits naturally into your existing dev workflow.

🤖 Using StyleGuard with Claude Code (Console Automation)

AI tools can generate UI code fast -
but they often ignore your design system.

Instead of relying on chat-based fixes, you can use Claude Code in the terminal to create a self-healing workflow.

💡 The Idea

Use StyleGuard + Claude Code CLI together:

StyleGuard detects issues
Claude Code reads console output
Claude Code automatically fixes the code
Loop continues until no violations remain No manual copying. No back-and-forth.

🔁 Automated Workflow (Real Dev Setup)

Step 1: Generate or modify UI code

(Manually or using Claude Code)

Step 2: Run StyleGuard

styleguard validate -s ./tokens.json -p ./src

Step 3: Console Output (Example)

❌ Invalid color: #123456 not in approved palette
❌ Margin: 18px not part of spacing scale
❌ Font-size: 15px not allowed

Step 4: Let Claude Code Fix It Automatically

Using Claude Code CLI, you can pipe or feed errors directly:

styleguard validate -s ./tokens.json -p ./src > errors.txt

claude-code fix ./src --rules ./tokens.json --input errors.txt

Or fully automated loop:

until styleguard validate -s ./tokens.json -p ./src; do
    claude-code fix ./src --rules ./tokens.json
done

🔄 What’s Happening Here?

StyleGuard acts as a strict validator
Claude Code acts as an auto-correcting engine
Your design system becomes enforced in code

This creates a closed feedback loop inside your terminal.

🌱 Consistency Is Not Optional Anymore

Modern products demand:

Speed
Scalability
Consistency

Without automation, maintaining design quality becomes difficult.
StyleGuard ensures your UI stays clean, consistent, and production-ready.

Ask yourself:

Are your styles consistent across pages?
Do developers strictly follow design tokens?
Is UI review taking too much time?

If yes - automation is the solution.

Stop relying on manual checks.
Start validating your UI automatically.

Make consistency a default - not an afterthought.

Web Accessibility: Designing Digital Experiences Everyone Can Use

PRANAV BHARTI — Fri, 02 Jan 2026 06:52:30 +0000

Your website is often the first conversation with your customer.

But what if some people can’t even join that conversation?

Web accessibility ensures that everyone, including people with disabilities, can perceive, understand, navigate, and interact with your digital products.

And today - it is no longer optional.

What Is Web Accessibility? 🧑‍💻

Web accessibility means building websites and applications that work for:

People with visual impairments
People who use screen readers
People who navigate using only a keyboard
People with hearing, cognitive, or motor disabilities
People on older devices, slow networks, or small screens

Accessibility improves usability for everyone - not just users with disabilities.

Good accessibility is simply good design.

Why Web Accessibility Matters 🚨

1. It Expands Your Audience

More than 1 billion people worldwide live with some form of disability.

An inaccessible website silently excludes them.

Accessibility means:

More users
More engagement
More conversions

2. It Is a Legal Requirement

Accessibility laws are enforced globally:

United States: ADA, Section 508
United Kingdom: Equality Act, Public Sector Accessibility Regulations
India: Rights of Persons with Disabilities Act (RPWD)

Non-compliance can lead to:

Legal notices
Financial penalties
Brand reputation damage

3. It Improves SEO and Performance

Accessible websites usually have:

Clean, semantic HTML
Proper headings and structure
Better mobile usability
Faster load times

Search engines and assistive technologies consume content in similar ways.

Accessibility directly supports SEO and discoverability.

What Does an Accessible Website Look Like?

An accessible website:

Works without a mouse
Has readable text and proper color contrast
Supports screen readers correctly
Uses meaningful headings and landmarks
Provides text alternatives for images
Maintains logical focus order

You may not see accessibility -

but users will experience it.

How Can You Quickly Check Your Website? 🔍

A very quick self-check:

Navigate using only the Tab key
Zoom the page to 200%
Disable images - does content still make sense?
Run a basic audit using Lighthouse or WAVE

These steps reveal surface issues.

True accessibility requires expert evaluation and remediation.

Accessibility Is an Investment, Not a Cost

An accessible website is:

Easier to use
Easier to maintain
Easier to scale
Ready for future regulations

Most importantly - it is inclusive by design.

Quick Debugging Techniques for Playwright Tests

PRANAV BHARTI — Tue, 07 Oct 2025 16:58:39 +0000

“Debugging is like being the detective in a crime movie where you are also the murderer.” – Filipe Fortes

Playwright is a powerful tool for end-to-end testing, but debugging test failures can be tricky.

Based on my experience, I’ve put together a practical guide that covers structure, data parsing, configuration, timeouts, and debugging techniques.

Structuring Your Tests

A well-structured test suite makes it easier to locate and fix failing tests.

Keep your tests modular. Use describe blocks to group related tests.
Write reusable helpers for login, navigation, or data entry.
Organize test files by feature (e.g., login.spec.ts, dashboard.spec.ts).

Data Parsing Techniques

Data handling often causes hidden issues. Some tips:

Use JSON.parse() for structured test data and load it from external files.
For CSV data, use libraries like papaparse or csv-parse.
Ensure consistent data types — always cast numbers explicitly when reading from strings.
Use environment variables for sensitive values like credentials.

By standardizing how you parse and use data, you reduce unexpected mismatches during tests.

Configuration Techniques

Playwright offers a central playwright.config.ts file that controls how tests run. Key settings include:

Browsers: Run against multiple browsers by setting projects.
Retries: Add retries for flaky tests with retries: 2.
Reporters: Use html or json reporters for better visibility.
Base URL: Define use: { baseURL: "http://localhost:3000" } to simplify navigation.

Keep configurations consistent across environments using .env files and environment variables.

Handling Timeouts

Timeouts are one of the most common debugging headaches.

Global Timeout: Set in playwright.config.ts with timeout: 30000.
Action Timeout: Control time for specific actions using page.setDefaultTimeout(5000).
Navigation Timeout: Use page.setDefaultNavigationTimeout(10000) to catch slow page loads.

✅ Always prefer await page.waitForSelector() over hard waits like page.waitForTimeout(5000).

Proper timeout management prevents both flaky tests and long waits during failures.

Debugging Techniques

When a test fails, use these approaches to identify the root cause quickly:

Run with npx playwright test --debug to open the inspector.
Use page.pause() inside a test to stop execution and explore manually.
Enable tracing with npx playwright test --trace on to capture screenshots, console logs, and network calls.
Add console.log() statements for critical variables to check runtime values.
Capture video or screenshots on failure by enabling it in the config file.

These methods help you narrow down issues without guesswork.

Final Thoughts

Debugging doesn’t have to be painful.

By combining structured tests, clean configuration, and the right tools, you can save hours during development and focus on building great tests instead of chasing errors.

Hope this helps you debug faster!

Written by Pranav Bharti

The Cursor AI Shortcut: How I Built and Deployed a LangChain AI Agent with CI/CD

PRANAV BHARTI — Mon, 30 Jun 2025 06:12:02 +0000

Struggling with deployments? Discover how I used Cursor AI to debug code, automate CI/CD, and deploy a Python web app to Azure!

Deploying a Flask app should be simple, but hidden bugs, dependency issues, and CI/CD hiccups can turn it into a nightmare.

That’s where Cursor AI changed the game for me.
By leveraging AI-assisted debugging, automated terminal commands, and smart error resolution, I cut my deployment time in half.

Here’s how you can do it too.

1. The AI-Powered Local Setup

Problem: Manual debugging is slow.
Cursor AI Fix: Instant code optimization.

Instead of wasting hours fixing bugs myself, I:
Prompt to Cursor AI:
Make this production-ready: remove dead code, fix errors, and generate a clean requirements.txt with exact versions.

Cursor AI automatically:

Removed unused imports
Fixed Gemini API key handling
Generated a lean requirements.txt (✅ no version conflicts!)

Pro Tip: Always specify _Only include dependencies I actually used_ to avoid bloat.

2. GitHub Push Without Typing a Single Command

Problem: Git workflows are tedious.
Cursor AI Fix: One-click repo setup.

I didn’t type a single Git command. Instead, I:

Created a GitHub repo and copied the SSH link
Told Cursor AI:

Prompt:
Push this project to my repo using SSH.

Cursor AI ran all the terminal commands:

git init git remote add origin git@github.com:myrepo/ethics-ai.git git add . git commit -m "AI-optimized initial commit" git push -u origin main

✅ Why This Matters: No more memorizing Git syntax—just deploy.

3. Azure Deployment: Where AI Saved Me from Disaster

Problem: Silent deployment failures.
Cursor AI Fix: Real-time error decoding.

After connecting GitHub to Azure, my app failed silently. Here’s how AI helped:

❌ Error 1
ModuleNotFoundError: No module named 'langchain'

Diagnosis
Azure doesn’t install dev dependencies. Move langchain from dev_requirements.txt to requirements.txt.

❌ Error 2
Blank Page on Startup

Solution
Flask needs a WSGI server like Gunicorn in production. Add a startup command in Azure Configuration:

Command

gunicorn --bind=0.0.0.0:8000 app:app

❌ Error 3
Gemini API Key Not Loading

Reminder
Azure doesn’t read .env files. Add the key in App Service > Configuration > Application Settings.

4. The Result: A Live AI App in Under 1 Hour

Thanks to Cursor AI:

Debugged code before deployment (no trial-and-error)
Automated Git workflows (no manual commands)
Solved Azure errors in minutes (not days)

Before AI: 6+ hours of debugging
After AI: 45-minute deployment

5. Your Turn: Try the AI Shortcut

Next Steps:

Install Cursor AI (VS Code extension)
Use my prompts (copy them above)
Deploy fearlessly—let AI handle the grunt work

Question for You
What’s your biggest deployment pain point?

Let me know in the comments—I’ll share how AI can fix it!

Call to Action

Try Cursor AI today and tag me in your deployment success story!

Final Thought

AI won’t replace developers—but developers using AI will replace those who don’t.