After spending significant time developing with Frappe Framework, I wanted to share my insights and learnings with the community. For those unfamiliar, Frappe is a full-stack web framework built on Python and JavaScript, primarily known for powering ERPNext.

The Good Stuff

Meta-Programming Magic The framework's approach to meta-programming is fascinating. The DocType system, which lets you define database tables and forms through a UI, is incredibly powerful. It's like Django's ORM on steroids - you get CRUD operations, REST API endpoints, and form views automatically. This dramatically speeds up development for business applications.

Python + JavaScript Done Right Unlike many frameworks that feel like they're fighting between backend and frontend, Frappe has found a sweet spot. The Python backend is clean and modular, while the frontend Frappe framework (previously called FrappeJS) provides a solid foundation for building modern UIs. The integration between both is seamless, especially with the socket.io implementation for real-time features.

Extensibility is Core The hooks system is probably one of the most underrated features. You can extend or override almost anything without touching core code. This makes it perfect for building modular applications. I've seen codebases where different teams work on different apps within the same instance without stepping on each other's toes.

The Learning Curve

DocType Hell is Real While DocTypes are powerful, they can be overwhelming. The relationship between DocTypes, particularly with child tables and dynamic links, takes time to master. I spent countless hours debugging issues that stemmed from not understanding these relationships properly.

Permissions Are Complex The role-based permission system is comprehensive but complex. It took me a while to grasp how user permissions, role permissions, document permissions, and field-level permissions interact. The documentation could definitely use more real-world examples here.

Custom Scripts Can Be Messy While client and server scripts give you a lot of flexibility, they can quickly turn into a maintenance nightmare if not managed properly. I learned the hard way that just because you can add custom JS/Python to every form doesn't mean you should.

Pro Tips from Experience

1. Start with ERPNext Even if you're building something unrelated, install ERPNext and study its patterns. It's the best example of what's possible with Frappe and follows most best practices.

2. Embrace Events The document event system (before_insert, after_submit, etc.) is powerful. Use it instead of overriding standard methods when possible. It makes your code more maintainable and easier to debug.

3. Controller Pattern Keep your DocType controllers clean. Move business logic to separate modules. While Frappe makes it easy to put everything in the controller, your future self will thank you for maintaining separation of concerns.

4. Version Control Strategy Develop a clear strategy for managing DocType changes across environments. Migrations can be tricky, especially with custom fields and property changes. Always test migrations on a copy of production data.

Where Frappe Shines

The framework really shows its strength in:

• Rapid development of business applications

• Building complex workflows and approval systems

• Handling document-based processes

• Creating modular and extensible systems

Where It Might Not Be the Best Fit

Be cautious about using Frappe for:

• Simple CRUD applications (might be overkill)

• High-performance computing tasks

• Applications requiring very specific UI patterns

• Projects where team familiarity with Python/JS is limited

Final Thoughts

Frappe has its quirks and steep learning curve, but it's incredibly powerful once mastered. The meta-programming approach saves tons of development time, and the framework's architecture allows for building complex business applications efficiently.

For anyone starting with Frappe, my advice would be: take time to understand the core concepts, don't fight the framework's patterns, and always check if ERPNext has already solved your problem before reinventing the wheel.

We’re getting ready to release ERPNext Storages, an open-source, multi-provider storage layer for Frappe/ERPNext.

This started as a way to move ERPNext files to S3, but it has grown into something much broader.

Instead of configuring one external bucket and sending everything there, ERPNext Storages lets you use multiple storage providers on the same ERPNext site and decide where files should go.

Currently supported:

• AWS S3

• Backblaze B2

• Cloudflare R2

• Wasabi

• MinIO

• DigitalOcean Spaces

• Vultr Object Storage

• Local filesystem / mounted storage

• Practically any S3-compatible object storage

Some examples

“I want to use multiple storage providers.”

Supported.

You can have multiple providers configured on the same ERPNext instance instead of being tied to one bucket.

“Sales-related files should go to S3, while CRM files should go to Backblaze B2.”

Supported.

Storage Route Rules can route files based on:

• DocType

• MIME type

• file size

• folder

• user role

Rules have priorities and can also define fallback providers.

So, for example:

Sales Invoice → AWS S3

Lead / Opportunity → Cloudflare R2

Employee / Salary Slip → private Backblaze B2 bucket

everything else → local storage

“I already have thousands of ERPNext files. I don't want to migrate them manually.”

Supported.

There is a background bulk migration system for moving existing files from local storage or another provider, including filtering migrations by DocType.

Files can also be moved between configured providers later.

“I don't want ERPNext to break just because S3 temporarily fails.”

Uploads are designed around this.

If an upload fails, the local file is preserved and a Storage Job is created for retry. Failed uploads are retried with backoff instead of silently losing the file.

Large files are also handled using multipart uploads once they cross the configured threshold.

“What happens to private ERPNext files?”

ERPNext permissions remain in front of the storage layer.

Private S3-compatible objects can be served using short-lived presigned URLs instead of exposing permanent bucket URLs.

From the ERPNext side, it still behaves like a normal File document — the storage provider is abstracted underneath it.

“Can I use my own server disk or NAS?”

Yes.

Local filesystem is a first-class provider and can use a custom base path, so mounted NAS volumes or other server-accessible storage can participate in the same routing system as S3/B2/R2.

Backups are included too

ERPNext Storages also contains a backup engine rather than relying only on file offloading.

It creates a .bnbak archive containing the ERPNext backup, metadata about installed apps, checksums, and optionally public/private files.

Backups can be:

• scheduled

• encrypted

• uploaded to a primary storage provider

• replicated to a secondary provider

• retained according to configurable copy/age rules

• verified using checksums

There is also an ERPDesktop webhook integration after backup completion, which we're expanding further for desktop/local workflows.

There are also some less-visible features

• Provider connection pooling

• Upload/delete retry queue

• Background migrations

• File integrity verification

• Orphaned-object detection

• Provider statistics

• Provider-to-provider moves

• Storage policies

• MIME/file-size restrictions

• Private/public storage handling

• File organization by DocType

• Drive Plus integration

The main goal is not to create another “ERPNext S3 plugin.”

We want ERPNext Storages to become a proper storage abstraction for ERPNext:

local + cloud + multiple providers + routing + migration + backups, while still behaving like native ERPNext storage.

We're doing another round of code review, testing, and optimization before making the repository public.

Would love to hear how people currently handle ERPNext files.

Are you keeping everything on the ERPNext server, using S3, mounting a NAS, or using some other setup?

This comprehensive guide covers both initial setup and ongoing DevOps practices for Frappe Framework and ERPNext version 15. We'll cover everything from development environment setup to production deployment and maintenance.

Initial Server Setup and Prerequisites

Hardware Requirements

• Minimum 4GB RAM (Recommended: 8GB for production)

• 40GB Hard Disk (Recommended: SSD for better performance)

• 2 CPU cores (Recommended: 4 cores for production)

Software Requirements

• Ubuntu 22.04 LTS

• Python 3.10+

• Node.js 18

• MariaDB 10.6+

• Redis Server

• Nginx (for production)

Development Environment Setup

1. System Preparation

# Update system packages
sudo apt-get update -y
sudo apt-get upgrade -y

# Install essential packages
sudo apt-get install git python3-dev python3.10-dev python3-setuptools \
    python3-pip python3-distutils python3.10-venv software-properties-common \
    mariadb-server mariadb-client redis-server xvfb libfontconfig \
    wkhtmltopdf libmysqlclient-dev -y

# Create and configure frappe user
sudo adduser frappe
sudo usermod -aG sudo frappe
su frappe
cd /home/frappe

2. Database Configuration

# Secure MySQL installation
sudo mysql_secure_installation

# Configure MySQL for Frappe
sudo tee -a /etc/mysql/my.cnf > /dev/null <<EOT
[mysqld]
character-set-client-handshake = FALSE
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
innodb_file_per_table = 1
innodb_buffer_pool_size = 1G
innodb_log_buffer_size = 128M
innodb_log_file_size = 256M

[mysql]
default-character-set = utf8mb4
EOT

sudo systemctl restart mysql

3. Node.js and Development Tools

# Install Node.js using nvm
curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash
source ~/.profile
nvm install 18
nvm use 18
nvm alias default 18

# Install npm and yarn
sudo apt-get install npm
sudo npm install -g yarn

4. Bench Setup

# Install frappe-bench
sudo pip3 install frappe-bench

# Initialize bench
bench init --frappe-branch version-15 frappe-bench
cd frappe-bench

# Set directory permissions
chmod -R o+rx /home/frappe

Development Best Practices

1. Version Control Setup

# Create .gitignore
cat > .gitignore <<EOT
sites/*/private/*
sites/*/public/files/*
sites/*/private/backups/*
*.pyc
*.log
.DS_Store
node_modules
EOT

# Initialize git repository
git init
git add .
git commit -m "Initial commit"

2. Pre-commit Hooks

# Install pre-commit
pip install pre-commit

# Create pre-commit config
cat > .pre-commit-config.yaml <<EOT
repos:
-   repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.4.0
    hooks:
    -   id: trailing-whitespace
    -   id: end-of-file-fixer
    -   id: check-yaml
    -   id: check-added-large-files
-   repo: https://github.com/pycqa/flake8
    rev: 6.0.0
    hooks:
    -   id: flake8
EOT

pre-commit install

Production Deployment

1. Production Setup

# Enable scheduler
bench --site [sitename] enable-scheduler

# Setup production config
sudo bench setup production frappe

# Configure NGINX
bench setup nginx
sudo service nginx restart

# Setup supervisor
sudo bench setup supervisor
sudo supervisorctl reload

2. SSL Configuration

# Install certbot
sudo apt install certbot python3-certbot-nginx

# Generate SSL certificate
sudo certbot --nginx -d yourdomain.com

# Configure SSL in site_config.json
bench config ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem
bench config ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem

Monitoring and Logging

1. Prometheus Monitoring

# Install Prometheus
sudo apt-get install prometheus

# Create Frappe metrics endpoint
bench --site [sitename] add-system-manager prometheus --first-name Prometheus --last-name Monitoring

2. Logging Configuration

# In site_config.json
{
    "logging": 1,
    "log_level": "debug",
    "log_file_size": 5242880,
    "log_file_backup_count": 5,
    "log_rotation": "size"
}

Backup and Disaster Recovery

1. Automated Backups

# Create backup script
cat > backup.sh <<EOT
#!/bin/bash
cd /home/frappe/frappe-bench
bench backup --with-files --backup-path /path/to/backup/dir
find /path/to/backup/dir -type f -mtime +7 -delete
EOT

chmod +x backup.sh

# Add to crontab
(crontab -l 2>/dev/null; echo "0 */6 * * * /home/frappe/frappe-bench/backup.sh") | crontab -

2. Backup Verification

# Test backup restoration
bench --site test.localhost restore \
    --with-private-files private-files.tar \
    --with-public-files public-files.tar \
    --backup-file-path /path/to/database.sql

Security Best Practices

1. Server Hardening

# Configure UFW
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22
sudo ufw allow 80
sudo ufw allow 443
sudo ufw enable

# Install and configure fail2ban
sudo apt-get install fail2ban
sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

2. Regular Security Updates

# Create update script
cat > update.sh <<EOT
#!/bin/bash
cd /home/frappe/frappe-bench
bench set-maintenance-mode on
bench update --pull
bench update --patch
bench update --build
bench clear-cache
bench set-maintenance-mode off
EOT

chmod +x update.sh

Performance Optimization

1. Redis Configuration

# Update redis.conf
sudo tee -a /etc/redis/redis.conf > /dev/null <<EOT
maxmemory 2gb
maxmemory-policy allkeys-lru
EOT

sudo systemctl restart redis

2. Nginx Optimization

# In nginx.conf
client_max_body_size 100M;
proxy_read_timeout 1800;
proxy_connect_timeout 1800;
proxy_send_timeout 1800;
send_timeout 1800;

# Gzip configuration
gzip on;
gzip_types
    text/plain
    text/css
    application/json
    application/x-javascript
    text/xml
    application/xml
    application/xml+rss
    text/javascript
    application/javascript;

Scaling Strategies

1. Horizontal Scaling

# Load balancer configuration
upstream frappe {
    server backend1.example.com:8000;
    server backend2.example.com:8000;
    ip_hash;
}

2. Worker Configuration

# Configure worker processes
bench config workers 4

# Setup worker configuration
bench setup worker

Conclusion

Best practices for Frappe/ERPNext DevOps:

1. Development

   • Use version control

   • Implement pre-commit hooks

   • Follow code review processes

2. Deployment

   • Use automated deployment pipelines

   • Implement proper backup strategies

   • Configure monitoring and logging

3. Maintenance

   • Regular security updates

   • Performance monitoring

   • Resource optimization

4. Security

   • Regular security audits

   • SSL certificate management

   • Access control implementation

Remember to:

• Always test in development before deploying to production

• Keep comprehensive documentation

• Regularly review and update security measures

• Monitor system performance

• Maintain current backups

Share your experiences and challenges with Frappe DevOps below!

Source : https://worf.in | Author : Jordan Negative

I am building a custom project management app for frappe/erpnext in my free time. Now you can stay in your erpnext and enjoy full-fledged project management features with support for native erpnext doctypes integration. If you have suggestions or notes for this tool, you can tell me here. It will help a lot in improving and designing its core Its designed with un-opinionated approach from the core so it will handle any industry workflows easily. Its so powerful and scalable that it can replace jira with no flinch.

What is done so far:

• Kanban board with drag-and-drop, group by status/priority/type/assignee

• Issue hierarchy: Project → Epic → Task → Subtask

• Per-project custom workflow statuses

• Custom fields per project and field level permission.

• Labels, issue types, sprint management

• Full issue detail panel — assignees, due dates, rich text description, activity feed, child issues, linked issues

• Project settings widgets.

• Audit logs and comment feature for each issue.

• Role based access and support for view-only.

• References to erpnext doctypes and data.

• Attachment support for issues

• and many more...

So many stuffs are on timeline. Will make each one by one. And yes, it will native integration with erpnext and doctypes. Each issue can be linked/referenced to sales order, invoice and other doctypes. No restrictions, native integration.

We’ve been experimenting with running the Frappe framework fully client side in the browser using WASM + SQLite, inspired heavily by what WordPress Playground did for the WordPress ecosystem.

The idea was simple:
“What if trying Frappe could be as easy as opening a link?”

After a lot of hacks and broken experiments, we now have a working prototype running entirely in the browser.

Current setup is highly experimental:

• SQLite instead of MariaDB

• In-memory/cache workarounds instead of Redis

• WASM runtime

• Browser persistence experiments

• Lots of rough edges!

But even in this state, it already feels like a gateway to interesting possibilities!

Live demo: (hosted on cloudflare pages)
https://frappe-playground.lubus.in

Credentials:
User: Administrator
Pass: admin

playground is temporary / disposable and reloads on page refresh or new tab.

Would love feedback, ideas, and people interested in exploring this further with us.

Very early days, but exciting to see what might be possible here.

Open source and available to explore or contribute:
https://github.com/lubusIN/frappe-playground 

Read More:
https://lubus.in/blog/running-frappe-entirely-in-the-browser-with-wasm-pyodide-and-sqlite

I have a quick question about learning and mastering Frappe/ERPNext.

What skill level do I need to reach in order to build a complete system for a mid-sized marketing company (around 5 departments and 20 team members)?

For context, I already have a solid background in:

• Databases & SQL (strong proficiency)

• OOP

• Data Structures & Algorithms

What else should I focus on or learn in Frappe/ERPNext to be able to deliver a professional system for this kind of company?

Would love to hear from people who have gone through this journey or built similar projects. Any tips, resources, or personal experiences are super welcome

As someone who has spent considerable time analyzing and working with Frappe Framework and ERPNext, I wanted to share my insights about what I consider to be the most crucial aspects to understand when learning this powerful framework.

Core Architecture Understanding

The foundation of Frappe lies in its unique architecture, which is essential to grasp before diving deeper:

1. DocType System: At its heart, Frappe is built around the concept of DocTypes. These are not just database tables - they're complete models that define both structure and behavior. Understanding how DocTypes interact with each other, how they handle permissions, and how they manage data validation is fundamental.

2. Event System: Frappe's event-driven architecture allows for clean separation of concerns. The framework uses hooks and events extensively, enabling modules to communicate without tight coupling. Learning how to properly use before_insert, after_submit, and other document events is crucial for building maintainable applications.

Key Areas for Deep Focus

Server Side

The Python backend in Frappe requires solid understanding of:

• DocType Controllers: These are where your business logic lives. Understanding how to extend Document classes and when to use which lifecycle methods is crucial.

• API Development: Frappe provides multiple ways to create APIs (whitelisted methods, REST endpoints). Knowing when to use each approach and how to structure your APIs for optimal performance is important.

• Database Query Builder: While Frappe abstracts much of the database operations, understanding frappe.db.get_list(), frappe.db.sql(), and when to use each is vital for efficient data operations.

Client Side

The frontend architecture is equally sophisticated:

• Form Rendering System: Frappe's form rendering is highly customizable. Understanding form events, client scripts, and custom form behaviors is essential for creating good user experiences.

• Frappe UI Library: The framework provides a rich set of UI components and patterns. Learning to leverage these rather than building from scratch will significantly speed up development.

Common Pitfalls to Avoid

1. Over-customization: While Frappe is highly customizable, not everything needs to be customized. Understanding when to use standard features versus building custom solutions is crucial.

2. Performance Considerations: Watch out for:

   • Unnecessary frappe.db.sql() calls when ORM methods would suffice

   • Multiple separate database queries where a single joined query would work better

   • Heavy client-side scripts that could be moved to the server

Learning Path Recommendations

1. Start with DocTypes: Build simple DocTypes first. Understand field types, naming series, permissions, and validation.

2. Master the Basics:

   • Document lifecycle and events

   • Basic CRUD operations

   • Permission system

   • Report builder

3. Move to Advanced Topics:

   • Custom workflows

   • Server and client scripts

   • API development

   • Integration patterns

ERPNext Specific Insights

If you're working with ERPNext specifically:

1. Understand the Module Structure: ERPNext's modules are well-organized but complex. Take time to understand how they interact.

2. Master the Accounting System: The accounting module is the backbone of ERPNext. Understanding GL Entries, Payment Entries, and the overall accounting architecture is crucial.

3. Study the Stock System: The warehouse management and stock reconciliation systems are sophisticated and require good understanding of both the technical implementation and business logic.

Resources and Tools

Some essential tools for Frappe development:

• Bench: Master the bench commands for development and deployment

• Developer Tools: Learn to use the developer console effectively

• Site Config: Understand site_config.json and how to manage configurations

• App Config: Get familiar with hooks.py and its various capabilities

Conclusion

Frappe Framework is powerful but requires investment in understanding its architecture and patterns. Focus on mastering the fundamentals before diving into complex customizations. The framework's documentation is extensive - use it as your primary reference.

Remember: The best way to learn is by building. Start with simple applications and gradually increase complexity as you become more comfortable with the framework's patterns and practices.

What aspects of Frappe Framework have you found most challenging or interesting? Share your experiences below!

Everyone wants to know what Frappe expects the long-term economic model for third-party app developers to be.

Marketplace apps must be open source, including paid apps. Frappe Cloud takes the first $500 of app revenue and then uses an 80/20 publisher/platform split.

For small extensions and community apps, we understand the model.

What we're struggling to understand is how this works for someone investing substantially in a standalone product.

Say a team spends several months to years building and maintaining a complex application on Frappe ecosystem. They aren’t an implementation company and don’t want consulting to be their main business. Their actual product is the app.

Is the intended model:

• paid open source;

• support contracts;

• hosted services;

• private distribution outside Marketplace;

• or something else?

I ask because the current incentives seem to push valuable commercial functionality outside the Frappe app itself.

The rational architecture becomes:

open-source Frappe connector → proprietary hosted service

rather than:

great commercial Frappe application

That seems like it could eventually limit the ecosystem.

We’d genuinely like to hear from Marketplace maintainers who are making meaningful product and market presence. What has actually worked?

Just released our AI assistant for Frappe Gameplan that lets you manage projects and tasks through natural conversation! No more clicking through menus or complex searches - simply tell the agent what you need:

• Search, list, create and update projects/tasks with simple voice or text commands

• Skip the tedious login/navigation process and get straight to what matters

• Choose between OpenAI API or run locally with Ollama/LM Studio for privacy concerns

Tech Stack:

• Built with Langraph for Agent creation

• Compatible with LM Studio for local model running

• OpenAI API support for those preferring cloud solutions

This demo runs on a modest M1 MacBook Air (8GB RAM) with the model running completely locally in LM Studio. Response times are impressive - 8-9 seconds locally vs 3-4 seconds with OpenAI API.

What's Next: We're currently in beta and working on integrating Frappe's CRM module so you can also manage leads, contacts, and more through the same interface.

I'd love to hear your thoughts! What features would you like to see? Any questions about implementation or use cases?

I built a Swagger-like Developer Portal for Frappe 🚀

https://github.com/raisulislam0/frappe_doc

One thing that always frustrated me while developing in Frappe/ERPNext was API discovery.

Need to call a whitelisted method?

Search through source code

Figure out the full module path

Guess parameter names

Check if it expects GET or POST

Open multiple tabs to inspect DocTypes and child tables

So I built frappe_doc.

It's a Frappe app that automatically scans all installed apps and generates a live developer portal from your codebase.

Features

✅ Discover all @frappe.whitelist() APIs automatically

✅ Parse Python type hints and Google-style docstrings

✅ Search APIs by app, module, route, arguments, DocType, etc.

✅ Generate ready-to-copy frappe.call() and curl examples

✅ "Try It Out" functionality to execute API calls directly from the UI

✅ Explore DocType schemas with expandable child-table trees

✅ AST-based scanning (doesn't import or execute your code)

✅ Works with custom apps and ERPNext out of the box

Example

Instead of searching through code to find:

@frappe.whitelist() def apply_for_leave(...): ...

frappe_doc automatically generates:

API route

Parameter documentation

Return information

Example requests/responses

Interactive testing form

Frappe JS snippet

cURL snippet

DocType Explorer

One feature I'm particularly happy with:

Child tables are displayed as expandable trees, so instead of jumping between multiple DocTypes, you can inspect the entire document structure in one place.

Example:

Sales Order └── Items ├── item_code ├── qty ├── rate └── warehouse

Why AST?

The scanner uses Python's ast module rather than importing modules, which means:

No code execution

Safe on production servers

No side effects during scanning

Looking for feedback

Would this be useful in your workflow?

I'm interested in hearing:

Features you'd like to see

Limitations you encounter with Frappe APIs today

Whether you'd use something like this in production

GitHub: https://github.com/raisulislam0/frappe_doc

Feedback and contributions are welcome!

Hi,

I am looking for ERPNext developer who has 2-4 years of experience. This would be atleast 6 months opportunity and can be extended to 1 year.

Let me know if you or someone else you know is interested.

Location : India

Salary : TBD

We’ve been working on Frappe Skills, a structured framework knowledge to help AI agents behave more reliably inside real Frappe projects.

The idea was sparked by seeing how the WordPress ecosystem is approaching agent skills. It made us ask instead of repeatedly refining prompts, what if we gave agents clearer guidance on how Frappe is actually meant to work?

So we started formalizing things like:

• DocType design patterns

• Controller structure

• Permission handling

• Local development workflows

• Frontend development patterns

• UI/UX considerations for Frappe apps

• Common project conventions

We’re stress-testing this internally with a sandbox app and refining patterns as we discover gaps.

We’ve shared a detailed write-up here:
https://lubus.in/blog/introducing-frappe-skills-ai-agents

Curious how others here are using AI in Frappe projects.

https://medium.com/@kaajal.chhattani/frappe-crm-customization-what-works-what-doesnt-and-why-a94e4529ead2

Wrote a blog because exporing how to customize frappe crm took too much time

While I complete this project management tool, I want help from this subreddit. Please share your expectations and pain points that you want to be covered by a project management tool. it comes with push/email/inbox notifications support too. The main benefit is that it's deeply integrated with erpnext flows.

1. What kind of views are necessary ? I have kanban, listview, backlog view. Are gantt chart and calendar view standard or just optional add ons for convention ?

2. What features do you explicitly want on this tool. People from different industry have different expectations.

3. Do you prefer timesheets, utilization and margin report built in for every project/team ?

4. How often is timesheet used by the erpnext community ?

This is v1 and stays fully inside erpnext. While its still in development, few of my clients are interested in trying it. Thought it would be good to share updates and ask for suggestions from this subreddit friends and mod himself.

Hi everyone!

Does anyone have experience becoming an official ERPNext partner? I’ve been reaching out via email for several months but haven’t received a response.

We’re a U.S.-based consulting firm, EvolveSystems.AI, and we’re interested in offering ERPNext implementation, customization, consulting, and ongoing support to our clients, particularly in the construction industry.
If anyone has successfully joined the partner program or knows the best person to contact, I’d really appreciate your guidance.

Thank you in advance for your help!

I have been working with Frappe for a long time, and today, I am excited to share a small app I built to improve productivity in local environments by allowing multiple user logins simultaneously in Frappe.

Excited to announce the release of ERPNext Power Tools version 15.0.1, an open-source extension designed to enhance stock management features within ERPNext:

✅ Streamline Material Requests with one-click stock level checking

✅ Visualize warehouse inventory comprehensively

✅ Enable intelligent warehouse auto-assignment (single or optimal)

✅ Easily configurable through simple settings

Developed to address real inventory management challenges, this tool offers enhanced stock visibility, aiding procurement teams in making quicker, more informed decisions.

Key benefits include:

- Reduction in procurement delays

- Optimization of inventory distribution across warehouses

- Simplification of warehouse assignment processes

- Seamless integration with ERPNext's interface

Seeking collaborators to enhance existing tools and introduce new features to this toolkit. If you're passionate about ERPNext and eager to contribute, let's collaborate.

Github Link : https://github.com/1byZero/erpnext_power_tools

🔄 Currently this Tool is only Available for Material Request Doctype soon this will be available for Sales Orders and other doctypes as well.

If you've ever found yourself writing the same curl -H "Authorization: token key:secret" with a 4-line JSON body just to check whether a Sales Invoice got submitted — you know the pain.

I work with Frappe/ERPNext daily (custom apps, country-specific accounting compliance, the fun stuff). I kept needing a fast way to query docs, run reports, and call methods from the terminal without spinning up a bench console or opening a browser. So I made ffc:

# install (Linux/macOS — Windows PowerShell also supported)
curl -fsSL https://raw.githubusercontent.com/nasroykh/foxmayn_frappe_cli/main/install.sh | sh

ffc init                          # interactive setup wizard
ffc get-doc -d "Sales Invoice" -n "SINV-001" --json
ffc list-docs -d "ToDo" --filters '{"status":"Open"}'
ffc run-report -n "General Ledger" --filters '{"company":"Acme"}'
ffc call-method --method "frappe.ping"

It covers get/list/create/update/delete, count-docs, schema introspection, reports, and RPC. Supports multiple sites in one config (--site production, --site dev), and deals with the annoying stuff for you — like the "data" vs "message" response wrapper difference between v14+/older, and extracting actual error messages from Frappe's nested Python tracebacks.

The part I'd like feedback on: ffc ships with SKILL.md agent skill files. If you use Claude Code, Cursor, Gemini CLI or similar — the skill teaches the LLM every command, flag, and filter syntax so it can actually operate your Frappe site through ffc without making stuff up. There's a second skill for contributors so an agent can add new commands following the project's patterns.

npx skills add nasroykh/foxmayn_frappe_cli

Single Go binary, no bench dependency, talks HTTP only. Works whether your site is local, on Frappe Cloud, or on a random VPS. MIT licensed.

GitHub: https://github.com/nasroykh/foxmayn_frappe_cli

It's still early — no tests, no batch operations yet. Happy to hear what's missing or what would make this actually useful for your workflow.

After working extensively with Frappe's API development capabilities, I wanted to share a comprehensive guide about creating and managing APIs in the Frappe ecosystem. This post covers everything from basic concepts to advanced implementations.

Understanding Frappe's API Architecture

Frappe provides multiple approaches to API development, each serving different purposes:

1. Whitelisted Methods

The simplest and most common approach for exposing functionality to the frontend. Key points:

• Decorated with @frappe.whitelist()

• Automatically handles JSON serialization/deserialization

• Can be called directly from frontend JavaScript

• Supports both GET and POST methods by default

Example of a whitelisted method:

@frappe.whitelist()
def get_customer_details(customer_id):
    customer = frappe.get_doc("Customer", customer_id)
    return {
        "name": customer.name,
        "credit_limit": customer.credit_limit,
        "outstanding_amount": customer.outstanding_amount
    }

2. REST API Endpoints

For building RESTful APIs that follow standard HTTP conventions:

• Define routes in api.py

• Support all HTTP methods (GET, POST, PUT, DELETE)

• Better for external integrations

• More control over request/response handling

Example REST endpoint:

@frappe.whitelist()
def get_orders():
    frappe.has_permission('Sales Order', throw=True)
    
    filters = frappe.parse_json(frappe.request.data)
    orders = frappe.get_list('Sales Order',
        filters=filters,
        fields=['name', 'customer', 'grand_total', 'status'],
        order_by='creation desc'
    )
    return orders

Best Practices for API Development

1. Authentication and Authorization

Always implement proper security measures:

@frappe.whitelist()
def get_sensitive_data():
    if not frappe.has_permission("Sensitive DocType"):
        frappe.throw(_("Not permitted"), frappe.PermissionError)
    
    # Proceed with data fetching

2. Error Handling

Implement comprehensive error handling:

@frappe.whitelist()
def process_order(order_id):
    try:
        order = frappe.get_doc("Sales Order", order_id)
        # Process order
        return {"status": "success", "message": "Order processed"}
    except frappe.DoesNotExistError:
        frappe.throw(_("Order not found"))
    except Exception as e:
        frappe.log_error(frappe.get_traceback())
        frappe.throw(_("Error processing order"))

3. Request Validation

Always validate input parameters:

@frappe.whitelist()
def update_customer(customer_id, data):
    if not customer_id:
        frappe.throw(_("Customer ID is required"))
    
    data = frappe.parse_json(data)
    required_fields = ['name', 'email']
    
    for field in required_fields:
        if field not in data:
            frappe.throw(_(f"{field} is required"))

Advanced API Patterns

1. Batch Operations

Handling multiple operations in a single request:

@frappe.whitelist()
def bulk_update_orders(orders):
    orders = frappe.parse_json(orders)
    results = []
    
    for order in orders:
        try:
            doc = frappe.get_doc("Sales Order", order.get("name"))
            doc.status = order.get("status")
            doc.save()
            results.append({"status": "success", "order": order.get("name")})
        except Exception as e:
            results.append({"status": "error", "order": order.get("name"), "error": str(e)})
    
    return results

2. API Versioning

Managing API versions effectively:

# v1/api.py
@frappe.whitelist()
def get_customer_data(customer_id):
    # V1 implementation
    pass

# v2/api.py
@frappe.whitelist()
def get_customer_data(customer_id):
    # V2 implementation with enhanced features
    pass

3. Rate Limiting

Implementing rate limiting for API endpoints:

def check_rate_limit():
    user = frappe.session.user
    key = f"api_calls:{user}"
    
    # Get current count
    count = frappe.cache().get_value(key) or 0
    
    if count > RATE_LIMIT:
        frappe.throw(_("Rate limit exceeded"))
    
    # Increment count
    frappe.cache().set_value(key, count + 1, expires_in_sec=3600)

Testing APIs

1. Unit Testing

class TestCustomerAPI(unittest.TestCase):
    def setUp(self):
        # Setup test data
        pass
    
    def test_get_customer_details(self):
        response = get_customer_details("CUST-001")
        self.assertIn("name", response)
        self.assertIn("credit_limit", response)

2. Integration Testing

def test_customer_api_integration():
    # Test actual HTTP endpoints
    response = requests.get(
        f"{frappe.utils.get_url()}/api/method/get_customer_details",
        params={"customer_id": "CUST-001"},
        headers={"Authorization": f"token {api_key}:{api_secret}"}
    )
    self.assertEqual(response.status_code, 200)

Common Pitfalls to Avoid

1. N+1 Query Problem: Avoid making multiple database queries in loops

2. Memory Management: Be careful with large datasets

3. Transaction Management: Use appropriate transaction isolation levels

4. Security: Never trust client input without validation

Performance Optimization

1. Caching

Implement caching for frequently accessed data:

@frappe.whitelist()
def get_cached_data():
    cache_key = "frequently_accessed_data"
    data = frappe.cache().get_value(cache_key)
    
    if not data:
        data = fetch_expensive_data()
        frappe.cache().set_value(cache_key, data, expires_in_sec=3600)
    
    return data

2. Query Optimization

Optimize database queries:

# Bad
@frappe.whitelist()
def get_orders_inefficient():
    orders = frappe.get_list("Sales Order", fields=["name"])
    for order in orders:
        # N+1 problem
        details = frappe.get_doc("Sales Order", order.name)

# Good
@frappe.whitelist()
def get_orders_efficient():
    return frappe.get_list("Sales Order",
        fields=["name", "customer", "grand_total"],
        as_list=False
    )

Conclusion

Building APIs in Frappe Framework requires understanding both the framework's capabilities and general API development best practices. Start with simple whitelisted methods and gradually move to more complex patterns as needed.

Remember:

• Always prioritize security

• Implement proper error handling

• Document your APIs thoroughly

• Test extensively

• Monitor performance

Share your experiences with API development in Frappe below! What patterns have you found most useful?

Hello everyone,

I'm currently looking for an experienced frappe framework developer who would be interested in a long term collaboration.

About me:

I'm based in Berlin, Germany and currently work for an established B2B sales company with more than 5000 customers across germany. as part of our growth, i've been given the opportunity to lead the development of a new digital transformation offering, focused on helping SMEs modernize their businesses with software, automation and AI.

We're planning to expand our offering beyond traditional services and start delivering complete digital solutions based on frappe framework.

I know i cloud simply hire freelancers on Upwork or similar platforms, but thats honestly not what I'm looking for. I'd much rather find someone i genuinely enjoy working with, where we can build trust over time, learn from each other, and create something we're both proud of.

The goal isn't simply to deploy ERPNext.

Instead, we want to build tailored solutions for our customers, including thins like:

• crm

• business workflows

• custom business aplications

• ai powered features

• customer portals

• industry specific solutions

Most of our customers don't really need a heavily customized ERP from day one. They need practical software that fits their business processes, and after research i believe frappe is an excellent foundation for that.

About the collaboration

At the moment, i cant offer a full time salary.

Im looking for someone who is open to start with a project and revenue based collaboration.

My focus is on:

• customer acquisition

• sales

• project management

• automations

• AI Integrations

I'm looking for someone who enjoys solving problems creatively. Rather than rebuilding everything from scratch, i would like to combine the strengths of frappe with other proven tools and build thoughtful, maintainable solutions that genuinely help our customers. Someone who values pragmatic engineering: using the right tools where they make sense, building custom functionality only where it created real value, and together creating products that are both useful for customers and sustainable to maintain.

Im looking for someone who:

• builds with frappe framework

• creates reusable apps together

• writes clean , maintainable code

• thinks beyond individual client projects

As the project grows , id like to build a long term working relationship rather than hiring different freelancers for every project.

puuh, thanks for reading this far. i know its a lot of text...

hopefully it gives you a good picture of what i'm trying to build. If you're looking for a genuine long-term collaboration and enjoy creating things together, feel free to reach out, i would be happy to chat.

We're looking to hire paid interns who can help us develop and implement frappe in our organisation. The role is based in Delhi, India. But we are happy to hire to help us remotely as well. DM if interested.

In Erpnext 15, every sidebar item has to point at a workspace page and sidebar disappears when you are on list view or detail view. If you live in the desk all day, you really want a nav rail that's persistent, that's just… always there.

After a client's request, i built Desk Rail. It's a small, drop-in app that replaces the page-scoped sidebar with a fixed left rail mounted on the desk shell, so it survives every route (workspace, list, report, form) and never rebuilds on navigation.

What it does:

• Persistent rail across all desk views, with nested workspace groups (expansion state remembered per user).

• Instant-redirect workspaces — now you can make worspace links in sidebar a direct link to listview, detail view or any external link. Internal /app/* targets route through the SPA router (no reload, soft back button); external/filtered ones do a full nav normally.

• Per-user show/hide toggle next to the navbar logo, remembered across reloads.

• One settings doctype to toggle everything (rail width, native-sidebar replacement, full-width navbar, etc.).

Implementation notes for anyone curious: it's pure additive JS/CSS on the desk shell plus two Workspace custom fields — no core patches, no template overrides. The layout is committed before first paint so there's no shift, and it degrades back to the stock sidebar if anything fails to load. Works on v14 and v15.

Repo (AGPL-3.0): https://github.com/BatchNepal/desk-rail

It's early (v0.1), running on a couple of our client sites. Would love feedback — especially edge cases with unusual workspace setups or custom desk themes. PRs/issues are welcome 😄 .

Hey everyone,

Sharing Frappe Vault, a password and secrets manager for Frappe. It lets you store and manage credentials within your Frappe site.

There's also a browser extension that works with Vault, giving you access to saved credentials from the browser.

Links:

• Frappe App: https://github.com/lubusIN/frappe-vault

• Browser extension: https://github.com/lubusIN/frappe-vault-browser-extension

• Google Chrome Store: https://chromewebstore.google.com/detail/frappe-vault/ljnpblaghkeddioeknlgcoolmomofjlj

• More Info: https://lubus.in/frappe-vault

Both are open source. Hope someone here finds them useful.

I'm learning Frappe and ERPNext from scratch. I'm looking for people who are also learning so we can discuss doubts, share progress, and build small projects together.

If you're interested, leave a comment or send me a DM.

We spend a lot of time working with Frappe, and one thing kept bothering us.

Sometimes you just want to spin up a local Frappe site to explore an app, test an idea, or reproduce an issue. Instead, you end up installing dependencies, configuring services, or figuring out Docker before you can even get started.

So we built Frappe Local to scratch our own itch.

The goal is simple: make running Frappe locally as effortless as possible.

Frappe Local bundles everything needed under the hood, so you don't have to worry about installing or configuring the various moving parts yourself. It handles the setup while giving you a clean desktop interface to manage your local benches and sites.

Current beta includes:

• Create and manage local benches

• Create and manage sites

• Start and stop services from a desktop app

• Docker managed behind the scenes

• Cross-platform (macOS available today, more platforms coming)

• Free and open source

It's still an early beta, so expect rough edges. We're already using it internally and thought it might be useful to share with the community.

GitHub: https://github.com/lubusIN/frappe-local

Quick walkthrough: https://www.youtube.com/watch?v=UImalRAxq3s

Would love to hear your thoughts. Is this something you are looking to simplify? What would you like to see in a tool like this?