iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
Horilla CRM extensions are Django apps integrated through AppLauncher conventions. For developers building a custom module, the useful building blocks extend well beyond a model: app discovery, feature registration, navigation, event and dashboard hooks, and reusable views and UI components. Horilla’s own technical article describes an app as “a self-contained Django module that plugs into the platform through AppLauncher.”
What makes a Horilla CRM app extensible?
Horilla’s documented approach treats a custom feature as a modular Django app rather than a change scattered across the CRM’s root configuration. An app can provide its own URLs and convention-named modules, such as registration.py, signals.py, menu.py, and dashboard.py. AppLauncher is the integration point that mounts the app and makes its declared hooks available.
This separation gives a developer distinct places to connect data, platform capabilities, navigation, events, and screens. The patterns below are documented by Horilla; they are not an independent ranking or a guarantee that every detail is identical across repository versions.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitches1. AppLauncher integrates a module with the CRM
AppLauncher provides the convention-based integration contract. Horilla’s technical article describes configuring an app’s URL mounting, module, and namespace so the platform can load it without adding a separate entry for every extension to the project’s root urls.py.
#1 Best Overall
In practice, that means the app configuration is more than a name in Django’s installed apps: it identifies how the custom module is exposed to the CRM and which convention modules the platform should import. Follow the configuration format in the documentation for the exact Horilla version you are targeting; names and registration details are version-sensitive.
2. Feature registration connects models to platform capabilities
Creating a Django model defines data, but does not by itself make that model discoverable by every Horilla feature. The documented registration.py pattern registers models for capabilities such as global search and import/export. The article also discusses integrations for duplicate handling, approvals, workflows, reviews, and scoring.
Registration can be selective or use an all=True option in the documented examples. Choose deliberately: explicit feature selection makes the intended integrations clearer, while a broad registration setting should be used only when the model is meant to participate in all supported features. Confirm available options in the target version rather than assuming every model or capability is handled identically.
3. Menu registration makes a feature usable
A model can be registered and its views can exist, yet users still need a clear way to reach the feature. Horilla’s menu.py pattern declares navigation entries that are rendered at runtime, including sidebar and quick-create or navigation options described in the technical article.
Include the menu as part of feature design: decide where the module belongs in the sidebar, whether a quick-create entry is appropriate, and how the label and destination will make sense to the users who have access. The vendor’s capstone tutorial demonstrates adding a sidebar menu for its sample module.
4. Signals and dashboard hooks connect the app to CRM behavior
Signals for cross-module events
The standard app structure includes signals.py for event handling across modules. This gives a custom feature a documented place to respond to platform events without folding that integration into a view or model definition. Use the target version’s signal conventions and keep event-related behavior scoped to the events the feature actually needs.
Dashboard contributions
A separate dashboard.py hook is documented for chart contributions. It gives an app a place to contribute information to the CRM dashboard. The source establishes this as an extension pattern, but does not provide a basis for claims about dashboard performance or the behavior of every chart integration.
5. Reusable views, API code, and UI components complete the feature
Horilla’s documented structure combines generic class-based views, model forms, filters, namespaced URLs, serializers and router-backed API code, plus templates and HTMX partials. The capstone sample module includes list, detail, create, and edit views, with an API stub described as optional.
These pieces form an end-to-end feature: users need screens and routes to work with the data, while registration and navigation connect those screens to platform capabilities. Treat the API as an additional interface when the use case calls for it, not as a required part of every module.
Rank #4
How to build a custom Horilla CRM module
Horilla’s capstone tutorial presents a concrete path for a sample company-scoped Partner module. It is the vendor’s tutorial, not an independently executed procedure; check the current repository and documentation before using version-specific commands or code.
- Generate the app: the tutorial starts with
python manage.py start_horilla_app partners. - Configure integration: add the AppLauncher configuration, including the URL and module details required by the target version.
- Define the data: add the company-scoped
Partnermodel. - Register platform features: configure the sample model for import/export and global search.
- Build the interface: add the views and associated forms, filters, URLs, and templates needed for the feature.
- Add navigation and access control: declare the sidebar menu and permissions so the feature has a user-facing entry point and appropriate access rules.
- Add an API only if needed: the tutorial describes its API stub as optional.
Check the target version before implementing
Horilla’s CRM announcement labels v1.0.0 a stable release and is dated January 13, 2026. Separately, the repository includes upgrade instructions from v1.9 to v1.10.0, including a one-time sync_db procedure for renamed app labels. These references show why a tutorial command or configuration should not be copied blindly: determine the branch or release you are extending, then use its development and upgrade instructions. The available release information does not establish the latest release state conclusively.
The repository describes REST endpoints with token-based authentication, pagination and filtering, Swagger/OpenAPI documentation, outbound webhooks with configured triggers and retries, CSV/Excel import and export, bulk operations, and validation/error reporting. Treat these as repository-described capabilities and verify the endpoint and behavior in the version being customized.
Best Value
Plan for production operations
Adding a module does not remove the operational requirements of running the CRM. The repository’s production checklist calls out the following areas:
- Set
DEBUG=Falseand use a strongSECRET_KEY. - Configure the production database and email service.
- Set up HTTPS and static-file serving.
- Arrange backups, monitoring, and logging.
- Consider Redis where the deployment needs it, and configure firewall or security-group rules.
The repository’s performance guidance discusses database indexes, select_related and prefetch_related, connection pooling, read replicas, caching, HTMX, and CDN support. These are considerations rather than measured outcomes: no comparative benchmark is provided. Choose infrastructure and optimization work based on the actual deployment and workload, and verify the guidance against the version you run.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Recommended Free Tools
