Forem: PRANAV BHARTI

CI/CD for Salesforce Using GitHub Actions

PRANAV BHARTI — Fri, 22 May 2026 12:47:06 +0000

"Continuous Integration doesn't get rid of bugs, but it does make them dramatically easier to find and remove." - Martin Fowler

If you've ever deployed to Salesforce by manually clicking through change sets and praying nothing breaks in production, this post is for you. You'll learn how to build a real CI/CD pipeline using GitHub Actions that validates every pull request and deploys automatically on merge - no clicking required.

Why Manual Salesforce Deployments Are Slowly Killing Your Team

You know the drill. Someone builds a feature in their sandbox, pulls together a change set, and deploys it on a Friday afternoon. Then the on-call phone rings.

The problems with manual deployments aren't just about risk:

No repeatability - what worked on your sandbox may not match what's in the change set.
No audit trail - "who deployed what and when?" becomes a detective game.
Fear culture - teams avoid deploying often because each deployment is a high-stakes event.
Slow feedback - bugs found in prod cost 10x more to fix than bugs caught in a PR.

CI/CD flips this. Small changes, deployed frequently, validated automatically. The pipeline is your safety net.

The Stack You'll Need

Before writing a single line of YAML, here's what powers the whole thing:

Tool	Purpose
Salesforce CLI (sf v2)	Authenticate, deploy, and run tests from the command line
GitHub Actions	Orchestrate the workflow on push/PR events
JWT Bearer Flow	Passwordless authentication to your Salesforce org
sfdx-git-delta	Generate a delta package - deploy only changed metadata
Salesforce Code Analyzer v5	Static analysis to catch bugs before they hit the org

⚠️ Use sf (v2), NOT the deprecated sfdx CLI. Salesforce released sf v2 in July 2023 and sfdx is no longer maintained. Most examples online still use sfdx - don't follow them blindly.

One-Time Setup: Connected App and JWT Auth

GitHub Actions runs on a server with no browser. That means no OAuth redirects, no username/password. JWT Bearer Flow is the right approach - it's headless, secure, and what Salesforce recommends for CI/CD.

Step 1 - Generate a key pair on your local machine:

openssl genrsa -out server.key 2048
openssl req -new -x509 -nodes -sha256 -days 365 \
    -key server.key -out server.crt

This gives you server.key (the private key - guard it fiercely) and server.crt (the certificate you upload to Salesforce).

Step 2 - Create a Connected App in Salesforce:

Go to Setup > App Manager > New Connected App and configure it like this:

Check Enable OAuth Settings
Callback URL: https://login.salesforce.com/services/oauth2/callback
Check Use Digital Signatures and upload server.crt
OAuth Scopes: Manage user data via APIs (api), Perform requests at any time (refresh_token, offline_access)
Check Require Secret for Web Server Flow = OFF

After saving, note the Consumer Key - you'll need it shortly.

Step 3 - Pre-authorize your deployment user:

In the Connected App, click Manage > Edit Policies. Set Permitted Users to "Admin approved users are pre-authorized". Then go to the user profile and add the Connected App under Connected App Access.

💡 Skipping this step is the 1 reason JWT auth silently fails. The error message won't tell you this is the problem.

Step 4 - Add secrets to GitHub:

Go to your repo Settings > Secrets and variables > Actions and add:

Secret Name	Value
`SF_USERNAME`	Your Salesforce deployment user's email
`SF_CONSUMER_KEY`	Consumer Key from the Connected App
`SF_JWT_KEY`	Full contents of `server.key`
`SF_INSTANCE_URL`	`https://login.salesforce.com` (or your My Domain URL)

⚠️ Never commit server.key to your repo. Add it to .gitignore immediately.

Your Project Structure

Your Salesforce project needs to be in source format (not metadata format) for this pipeline to work. If you're still using the old metadata API format, run sf project convert source to migrate.

my-salesforce-project/
├── .github/
│   └── workflows/
│       └── salesforce-cicd.yml    ← your pipeline lives here
├── force-app/
│   └── main/
│       └── default/
│           ├── classes/
│           ├── lwc/
│           ├── triggers/
│           └── permissionsets/
├── config/
│   └── project-scratch-def.json
└── sfdx-project.json

The sfdx-project.json at the root tells the CLI where your source lives. Make sure it points to force-app.

The GitHub Actions Workflow

Here's a production-ready workflow that does two things:

On pull request - validates the code and runs Apex tests (no deployment)
On merge to main - deploys to your target org

name: Salesforce CI/CD

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  salesforce-cicd:
    name: Validate & Deploy
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Required for sfdx-git-delta to compare commits

      - name: Install Salesforce CLI
        run: npm install --global @salesforce/cli@latest

      - name: Authenticate to Salesforce
        env:
          SF_JWT_KEY: ${{ secrets.SF_JWT_KEY }}
        run: |
          echo "$SF_JWT_KEY" > server.key
          sf org login jwt \
            --client-id "${{ secrets.SF_CONSUMER_KEY }}" \
            --jwt-key-file server.key \
            --username "${{ secrets.SF_USERNAME }}" \
            --instance-url "${{ secrets.SF_INSTANCE_URL }}" \
            --set-default-org
          rm -f server.key

      - name: Validate on Pull Request
        if: github.event_name == 'pull_request'
        run: |
          sf project deploy validate \
            --source-dir force-app \
            --test-level RunLocalTests \
            --wait 30 \
            --verbose

      - name: Deploy on Merge to Main
        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
        run: |
          sf project deploy start \
            --source-dir force-app \
            --test-level RunLocalTests \
            --wait 30 \
            --verbose

The key difference: deploy validate does a check-only deployment (no actual changes). deploy start is the real thing.

Deploy Only What Changed: sfdx-git-delta

Deploying your entire force-app on every merge is slow and risky. If you have 500 Apex classes, why redeploy 499 that didn't change?

sfdx-git-delta (SGD) compares your current commit against the previous one and builds a package.xml containing only the changed metadata. This can slash deployment times from 20+ minutes to under 2.

Here's how to add it to your workflow, replacing the deploy step:

      - name: Install sfdx-git-delta
        run: echo y | sf plugins install sfdx-git-delta

      - name: Generate Delta Package
        run: |
          mkdir -p delta
          sf sgd source delta \
            --to "HEAD" \
            --from "HEAD~1" \
            --output delta \
            --generate-delta \
            --source-dir force-app

      - name: Deploy Delta (on merge)
        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
        run: |
          if [ -s delta/package/package.xml ]; then
            sf project deploy start \
              --manifest delta/package/package.xml \
              --test-level RunLocalTests \
              --wait 30
          else
            echo "No metadata changes detected - skipping deployment"
          fi

      - name: Deploy Destructive Changes
        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
        run: |
          if [ -s delta/destructiveChanges/destructiveChanges.xml ]; then
            sf project deploy start \
              --manifest delta/package/package.xml \
              --pre-destructive-changes delta/destructiveChanges/destructiveChanges.xml \
              --test-level NoTestRun \
              --wait 30
          fi

SGD also handles destructive changes automatically - if you deleted or renamed a class in git, it builds the destructiveChanges.xml for you.

Add Static Analysis with Salesforce Code Analyzer

Catching bugs before they reach the org is cheaper than fixing them after. Salesforce Code Analyzer v5 (released in 2025) runs PMD and other engines against your Apex, and has an official GitHub Action.

Add this step before your deploy/validate step:

      - name: Run Salesforce Code Analyzer
        uses: forcedotcom/run-code-analyzer@v2
        with:
          run-command: run
          run-arguments: >
            --target force-app
            --engine pmd
            --severity-threshold 2
          results-artifact-name: salesforce-code-analyzer-results

--severity-threshold 2 fails the build on any high or critical PMD violations. Set it to 3 if you want a softer start and work your way down.

Common Pitfalls (Save Yourself the Headache)

Using sfdx instead of sf
The old sfdx CLI is deprecated. Its commands look similar but behave differently. Always use sf org login jwt, not sfdx force:auth:jwt:grant.

Forgetting fetch-depth: 0
By default, actions/checkout only pulls the latest commit (a shallow clone). sfdx-git-delta needs the full git history to calculate the diff. Without fetch-depth: 0, it'll fail silently or compare against nothing.

Connecting App not pre-authorized
JWT auth will return a cryptic invalid_grant error. The fix is in the Connected App's Permitted Users policy - set it to admin-approved and explicitly grant access to the deployment user.

Using RunAllTests instead of RunLocalTests
RunAllTests runs managed package tests too, which can add 30+ minutes to your pipeline for no benefit. Use RunLocalTests unless you have a specific reason not to.

Leaving server.key on disk
Always rm -f server.key after authenticating. The example workflow above does this, but if you write your own steps, don't forget it.

Final Thoughts

CI/CD for Salesforce is not harder than any other platform - it just has more one-time setup. Once your Connected App is configured and your secrets are in place, the YAML almost writes itself. Start with a simple validate-on-PR workflow, prove the value to your team, then layer in delta deployments and static analysis as your pipeline matures.

The best deployment is one your team doesn't even have to think about.

Hope this helps you ship Salesforce changes with confidence!
Written by Pranav Bharti

Salesforce TDX 2026: The Rise of the Agentic Enterprise

PRANAV BHARTI — Thu, 07 May 2026 12:42:26 +0000

The future of enterprise technology is no longer just about applications, automation, or dashboards. At Salesforce TDX 2026, Salesforce introduced a bold vision for the next era of digital transformation - the Agentic Enterprise.

The conference showcased how AI agents are evolving from simple assistants into autonomous systems capable of collaborating with humans, orchestrating workflows, making decisions, and continuously improving operations across organizations.

This year’s keynote was not just another AI announcement. It represented a major architectural and strategic shift in how software will be built, deployed, and operated in the coming decade.

What is Salesforce TDX?

Salesforce TDX (Trailblazer Developer Experience) is Salesforce’s flagship developer and technology conference focused on innovation, AI, automation, application development, integrations, and the future of enterprise platforms.

TDX brings together:

Developers
Architects
IT leaders
Admins
AI engineers
Technology partners

The event typically showcases:

Product innovations
Future platform roadmaps
AI and automation strategies
Hands-on developer tools
Real-world customer success stories

At TDX 2026, Salesforce heavily emphasized AI-powered enterprise transformation through autonomous agents, modular architecture, and open ecosystem interoperability.

The Shift Toward the “Agentic Enterprise”

One of the biggest themes of the keynote was the transition from traditional software systems to what Salesforce calls the Agentic Enterprise.

In the past:

Humans operated software
Software executed predefined workflows
Automation was rule-based

Now, organizations are moving toward systems where:

AI agents collaborate with humans
Agents coordinate with other agents
Workflows become adaptive and intelligent
Systems continuously optimize themselves

Salesforce positioned this transformation as the next major technology evolution after:

Cloud computing
Mobile platforms
First-wave AI
Autonomous AI systems

The result is expected to be:

Exponential productivity gains
Faster decision-making
Reduced operational costs
Large-scale automation

Headless 360 Architecture: Salesforce’s Core Innovation

A major architectural announcement at TDX 2026 was the introduction of the Headless 360 Architecture.

Instead of tightly coupled enterprise applications, Salesforce proposed a modular and composable architecture built around four key layers:

1. System of Context
The centralized data layer containing customer, operational, and business information.

2. System of Work
Business logic and workflow orchestration.

3. System of Agency
AI agents responsible for automation, reasoning, and decision-making.

4. System of Engagement
The user experience layer across web, mobile, chat, and collaboration tools.

This API-first approach allows organizations to:

Reuse services dynamically
Enable AI orchestration across systems
Build composable enterprise workflows
Reduce dependency on monolithic applications

The architecture is designed specifically for AI-native enterprises.

Open Agent Ecosystem and MCP

Another important announcement was Salesforce’s support for an open agent ecosystem powered by MCP (Model Context Protocol).

Salesforce described MCP as:

“Lego blocks for AI systems.”

MCP enables:

Interoperability between AI agents
Communication across platforms
Standardized integrations with enterprise tools

The keynote highlighted integrations with platforms such as:

OpenAI
Anthropic
Slack

This approach reduces vendor lock-in and encourages ecosystem-driven innovation, allowing enterprises to combine multiple AI systems rather than relying on a single platform provider.

AI is Transforming the Software Development Lifecycle

Salesforce also demonstrated how AI agents are changing the traditional Software Development Lifecycle (SDLC).

Previously, software development followed a linear workflow:
Build -> Test -> Deploy -> Observe

At TDX 2026, Salesforce introduced an AI-assisted lifecycle that adds:

Agent orchestration
Automated experimentation
Continuous optimization
Intelligent testing systems

This new model supports both:

Deterministic systems (traditional software)
Probabilistic systems (AI-driven behavior)

The company demonstrated scenarios where development cycles that once took hours could now be completed in minutes using coordinated AI agents.

Developers Are Becoming AI Orchestrators

One of the most thought-provoking concepts from the keynote was the changing role of developers.

Instead of writing every line of code manually, developers will increasingly:

Manage multiple coding agents
Guide AI-generated implementations
Focus on architecture and product thinking
Operate like engineering managers for AI systems

Salesforce described this as:

1 developer = a team of AI agents

This creates the possibility of 10x productivity gains for engineering teams.

AgentForce: Salesforce’s Enterprise AI Platform

Salesforce introduced AgentForce, its enterprise-grade AI orchestration platform.

Key capabilities include:

1. AgentScript
Provides deterministic controls and guardrails for AI agents.

2. Agent Testing and A/B Experimentation
Allows continuous performance optimization and behavior validation.

3. Multi-Agent Orchestration
Enables multiple AI agents to collaborate across workflows.

4. Telemetry and Observability
Provides real-time monitoring and visibility into agent behavior.

The overall focus of AgentForce is enterprise trust, governance, scalability, and operational control.

Build Once, Deploy Everywhere

Another major innovation announced at TDX was Salesforce’s universal experience layer.

Organizations can define a UI once and automatically deploy it across:

Web applications
Mobile apps
Collaboration platforms
LLM interfaces

This includes integrations with:

Slack
Microsoft Teams
Chat-based AI interfaces like ChatGPT

The benefits are significant:

Eliminates duplicate frontend development
Reduces maintenance overhead
Accelerates deployment across channels
Creates seamless omnichannel experiences

This supports Salesforce’s broader “meet users where they are” strategy.

Agent Exchange and the $50 Million Ecosystem Fund

Salesforce also announced the Agent Exchange, a marketplace for:

AI agents
Skills
Reusable components
Automation modules

To accelerate ecosystem growth, Salesforce introduced a $50 million investment fund aimed at encouraging partner-led AI innovation.

This move could help create an entirely new AI application economy within the Salesforce ecosystem.

From Applications to Autonomous Systems

Perhaps the most important conceptual shift introduced at TDX 2026 was this:

Organizations are no longer simply building applications.

They are building:

Autonomous systems
Self-improving AI ecosystems
Multi-agent collaborative environments

These systems include:

Continuous learning loops
Feedback-driven optimization
Cross-agent coordination
Dynamic workflow adaptation

This marks a significant evolution in enterprise software design.

Democratizing AI Development

Salesforce also emphasized accessibility.

With:

Natural language interfaces
Low-code tooling
Agent-assisted development

Even non-technical users can increasingly build AI-powered solutions.

This democratization could dramatically expand the number of enterprise builders while reducing dependency on scarce AI specialists.

Final Thoughts

Salesforce TDX 2026 made one thing very clear: the enterprise software industry is entering a new era.

Salesforce’s vision extends beyond traditional CRM platforms and workflow automation. The company is positioning itself at the center of a future where:

AI agents collaborate with humans
Applications become autonomous systems
Development becomes AI-assisted
Enterprises operate through intelligent orchestration layers

Whether organizations are ready or not, the shift toward the Agentic Enterprise has already begun.

The next generation of enterprise platforms may not be defined by apps alone - but by networks of intelligent agents working together in real time.

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.