If you’ve been following my automation <a href="https://medium.com/@dhruvrana841999/how-i-built-a-lead-capturing-ai-chatbot-for-my-website-using-next-js-f1596aa75bea">work</a>, you’ll know I’ve been building out a self-hosted n8n stack. A lot of people assumed I was running it on a paid VPS — but the truth is, I run it entirely on Oracle Cloud’s Always Free tier, with zero ongoing server cost.
Here’s how the setup works, and why it holds up well against a typical Docker-on-a-paid-VPS approach.
<h3>The Setup</h3>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-L1e13nlOk1iSyVY1U4c_Q.png"></figure>I’m running n8n on a VM.Standard.E2.1.Micro instance — one of the shapes included in Oracle Cloud's lifetime free tier. I initially looked at the ARM-based A1. Flex shape for more headroom, but ran into capacity availability issues, so I settled on the E2 micro instance instead.
The stack itself is still Docker-based under the hood:
<ul>
<li>
n8n running in a container</li>
<li>
Postgres as the backing database instead of the default SQLite</li>
<li>
Caddy as a reverse proxy, handling HTTPS automatically</li>
</ul>
I deliberately kept the Docker Compose file simple — no Redis, no queue mode. Since my use case is webhook-driven rather than high-volume parallel execution, adding queue mode would have been unnecessary overhead for no real benefit.
<h3>Is It Comparable to a Regular Docker Setup?</h3>
Functionally, yes — the docker-compose.yml looks very similar to what you’d deploy on any paid droplet or EC2 box. The difference lies entirely in where it runs and what it costs, not in how n8n itself behaves.
That said, “free” comes with trade-offs worth knowing before you commit:
<ul>
<li>
Limited headroom. The E2 micro shape is genuinely micro. Running a resource-heavy IDE (I use VS Code for remote development) alongside the full n8n stack pushes it to its limits.</li>
<li>
Background noise adds up. I had to resolve orphaned Antigravity IDE processes and rein in Oracle’s own Cloud Agent monitoring plugin, which was quietly eating CPU it had no business eating.</li>
<li>
A few networking quirks. I hit an IPv6/IPv4 healthcheck conflict, an outdated n8n image tag that caused a database schema mismatch, and a Caddy startup dependency issue where Caddy tried to come up before n8n was actually ready. All fixable, but worth expecting.</li>
</ul>
None of these are dealbreakers — they’re the kind of small, solvable issues you’d expect when trading a bit of convenience for zero hosting cost.
<h3>Why Bother?</h3>
For personal automations, prototypes, and workflows that don’t need to scale to hundreds of concurrent executions, this setup gives you a fully self-hosted n8n instance — full data ownership, no per-execution billing, no vendor lock-in — for genuinely $0/month, indefinitely.
If you’re comfortable with basic Docker and Linux server management, it’s a solid way to run n8n without the recurring VPS bill.
Want to talk automation, Drupal, or backend architecture? Check out my portfolio: <a href="https://dhruv.nxtfusion.com/">dhruv.nxtfusion.com</a>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=34c093e7e645" width="1" height="1" alt="">

Running n8n for Free, Forever: My Oracle Cloud Free Tier Setup

<h3>How I Built a Lead-Capturing AI Chatbot for My Website Using Next.js, Make.com, and Gemini (Without Writing a Traditional Backend)</h3>
A build log on turning website visitors into leads — even the ones who never say goodbye.
<h3>The problem I was trying to solve</h3>
Most website chatbots do one thing well: answer questions. But very few of them close the loop for the business owner. A visitor chats, gets an answer, and leaves — and unless someone is manually reading transcripts all day, potential leads slip through unnoticed.
I wanted something different: a chatbot that not only talks to visitors intelligently, but also tells me when a conversation looks like a real lead — automatically, without me babysitting a dashboard.
Here’s how I built it, and the one gap I didn’t expect to matter as much as it did: users who just… disappear mid-conversation.
<h3>The stack</h3>
<ul>
<li>
Next.js — the chat widget embedded on the website</li>
<li>
Make.com — the automation/orchestration layer (no traditional backend server)</li>
<li>
Gemini — the LLM powering the actual conversation</li>
<li>
Make.com’s built-in data store — session and transcript storage</li>
</ul>
No custom database, no Express server, no hosting a separate API. Just a webhook and a set of scenarios.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9c2XaHKtufa09wDhk5B3WQ.png"><figcaption>Chatbot</figcaption></figure><h3>How a single message flows through the system</h3>
<ol>
<li>A visitor opens the chat widget and types a message.</li>
<li>The frontend sends a payload to a Make.com webhook containing: a session ID, the message, and an action (message or session_end).</li>
<li>Make.com checks its data store: does this session ID already exist? If so, it pulls the prior transcript.</li>
<li>The transcript, the new message, and a system prompt (defining the bot’s role and capabilities) are sent together to Gemini.</li>
<li>Gemini’s response comes back.</li>
<li>Make.com writes the updated transcript — user message, agent reply, and metadata — back into the data store using an add/replace module.</li>
<li>The response is sent back to the Next.js widget, and the visitor sees the reply in real time.</li>
</ol>
This part was the “easy” 80% — a fairly standard request/response loop, just orchestrated visually instead of in code.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T2aKjaQSOMmebzKus3RzVw.png"></figure><h3>The part that actually took thought: what happens when the user just leaves?</h3>
Here’s the thing nobody tells you about chatbot lead-capture: not every user clicks “End Chat.” Most just close the tab.
If I only generated a summary when a user explicitly ended their session, I’d miss a huge chunk of conversations — including ones where someone asked a detailed, high-intent question and then got distracted or closed their laptop.
So I built two parallel paths to the same outcome — getting me a usable summary of the conversation:
Path A — Explicit end. When a visitor clicks “End Session,” Make.com pulls the full transcript, generates a summary of what was discussed, and emails it to me for lead review.
Path B — The safety net. A separate scenario periodically checks all sessions marked “open” in the data store. If a session has had no activity for 30 minutes, it’s treated as abandoned. Make.com then reviews the transcript so far and sends me the same kind of summary, so I still find out if something worth following up on happened, even if the visitor never formally said goodbye.
Thirty minutes was a practical threshold: long enough that it’s not just a slow typer, short enough that the lead is still fresh when I see it.
<h3>Why this mattered more than the chatbot itself</h3>
The AI conversation is the visible, “cool” part. But the actual business value lies in not losing potential leads to silence. A chatbot that answers questions is a feature. A chatbot that makes sure a human always sees the promising conversations — whether or not the visitor closes the loop themselves — is a lead-generation system.
<h3>What I’d tell someone building this themselves</h3>
<ul>
<li>Treat “abandoned” as a first-class user action, not an edge case. Silence is still a signal.</li>
<li>Keep the system prompt and capabilities definition centralized — it’s the one thing you’ll iterate on constantly as you see real conversations come in.</li>
<li>No-code orchestration (Make.com, in my case) is genuinely viable for this kind of workflow — the logic is closer to “if this, then that across systems” than heavy computation, so it doesn’t need a hand-rolled backend.</li>
<li>Think early about duplicate notifications: if a session is later resumed after being marked idle, decide up front whether you want a fresh summary, an incremental one, or none at all. It’s a much easier decision before you have five overlapping scenarios than after.</li>
</ul>
<h3>The cost: effectively zero</h3>
One thing worth calling out explicitly, because I think it’s the most useful part for anyone else considering this: the entire setup costs nothing to run at low-to-moderate traffic.
<ul>
<li>The website itself is hosted on Vercel, on its free tier.</li>
<li>The entire orchestration layer runs on a free Make.com account.</li>
</ul>
That means there’s no infrastructure barrier to trying this. If you’re a solo developer, a small business, or just testing whether an AI chatbot is even useful for your visitors, you can have this exact functionality live without paying for hosting, a backend server, or automation tooling.
The upgrade path is there when you need it, not before:
<ul>
<li>If traffic grows and you start bumping into Make.com’s free-tier operation limits, moving to a paid plan is a straightforward next step — you’re scaling because the thing is working, not paying up front on faith that it will.</li>
<li>If you’d rather self-host the automation layer entirely (for cost, data control, or scale reasons), the same scenario logic — webhook in, session/transcript lookup, LLM call, write-back, abandoned-session sweep — maps cleanly onto n8n, which you can run yourself instead of relying on Make.com’s cloud.</li>
</ul>
So the path is: validate for free → upgrade Make.com if you outgrow the free tier → or move to self-hosted n8n if you want full control. None of those steps requires rebuilding the core idea.
<h3>What’s next</h3>
Right now, the summaries land in my inbox for manual review. The next iteration is scoring conversations by lead intent so the ones that actually matter surface first — but that’s a story for another post.
If you’re building something similar or have solved the “abandoned session” problem differently, I’d love to hear how — find me on LinkedIn.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=f1596aa75bea" width="1" height="1" alt="">

How I Built a Lead-Capturing AI Chatbot for My Website Using Next.js,

How I Fixed the Issue of Merge Fields Not Working When Uploading Documents Directly in DocuSign
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gRX7G2qAiCpZfdXcJJwWtw.png"></figure>Recently, I ran into a frustrating issue while working with DocuSign. Whenever I uploaded a Word document directly (for example, a simple file containing {{ name }}), the merge fields refused to update. Everything looked correct, but DocuSign simply didn’t replace the placeholders with actual values.
After investigating, I discovered the real reason: The document wasn’t recognized as a Document Generation–enabled document. And because of that, DocuSign ignored the merge fields entirely.
Once I studied the updated DocuSign document generation workflow, I realized that the way we upload Word files has changed. If you upload a document directly into a template without preparing it correctly, DocuSign will not activate the merge functionality.
To save you the same trouble, here’s the exact method that worked for me.
<h3>The Correct Way to Prepare and Upload a Document for DocuSign Document Generation</h3>
<h3>1. Open Your Document in Microsoft Word (Not Google Docs)</h3>
DocuSign’s merge engine only supports Word files that have been prepared using the right tools. Google Docs won’t embed the merge field metadata required for DocGen, so make sure you start with Microsoft Word.
<h3>2. Install the “Document Generation Template Assistant” Add-on</h3>
DocuSign provides an official Word add-in called Document Generation Template Assistant. Install it from the Microsoft Store inside Word.
This add-on lets you insert merge fields, validate your document, connect your DocuSign account, and prepare the file for Document Generation. Without this tool, your Word document will not be marked as DocGen-enabled.
<h3>3. Connect Your DocuSign Account Through the Add-on</h3>
After installing the add-on, log in using your DocuSign credentials. This creates a direct link between your Word document and your DocuSign templates, ensuring accurate field mapping and metadata handling.
<h3>4. Test and Replace Your Document Inside an Existing DocuSign Template</h3>
The Word add-on allows you to replace the existing document inside a DocuSign template with your updated file. This step is important because it keeps the template’s field mappings intact and ensures that the document gets registered as Document Generation Enabled.
Once I replaced the document through the add-in instead of uploading it directly, all my merge fields started working perfectly.
<h3>Final Thoughts</h3>
This updated workflow made the entire process smoother for me. If your placeholders like {{ name }} aren’t merging, there’s a good chance your document isn’t registered as a DocGen-enabled file.
Using the Document Generation Template Assistant add-on inside Word is the most reliable way to ensure your file is prepared correctly before sending it to DocuSign.
I hope this guide helps you resolve the issue just like it did for me.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=6c1b8169f381" width="1" height="1" alt="">

DocuSign Document Generation Not Working? Fix Word Template Merge Fields Not Replacing Values

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AOoRduj94mZAoJnq67Kegw.png"></figure>I just finished watching the DrupalCon Vienna 2025 keynote, and for the first time in a while, it didn’t just feel like a product update — it felt like a turning point.
The web is changing fast. AI is rewriting how people discover, consume, and even trust information. When 70% of searches now end in AI-generated answers, you start to wonder: where do websites fit in that new reality?
Dries didn’t dodge that question. He faced it head-on — and so did the community.
<h3>Drupal’s Hidden Advantage</h3>
For years, people have said Drupal was “too complex.” But that same complexity — the structured data, strong APIs, versioning, and permissions — now looks like a gift. It means Drupal is AI-ready by design.
While others are patching AI into rigid systems, Drupal’s architecture already speaks the same language — structured, contextual, composable.
<h3>What Stood Out for Me</h3>
<ul>
<li>
Aquia Source — an AI-powered, fully managed CMS on Drupal. It’s fast, secure, and actually respects content architecture.</li>
<li>
Drupal Canvas — a visual builder for marketers and creators, coming November 2025. It’s simple but still Drupal at heart.</li>
<li>
Figma Integration — design meets code in real time. That’s been a dream for years.</li>
<li>
ECA &amp; Active Pieces — workflow automation that can finally connect Drupal to the rest of the tech stack — natively and no-code.</li>
</ul>
All of it points to one thing: Drupal isn’t reacting to the AI era — it’s shaping it.
<h3>The Human Side</h3>
What really landed with me was the tone of the community. No panic, no hype — just builders figuring out how to keep the open web open. That’s rare.
As someone who’s worked in Drupal for years, this feels personal. Drupal’s always been about balance — structure and creativity, freedom and stability. Now, it’s about weaving AI into that same balance.
<h3>My Takeaway</h3>
We’re not just maintaining old websites anymore; we’re reimagining what a website is. And Drupal’s uniquely positioned to lead that shift — not because it’s perfect, but because it’s flexible enough to evolve.
If you’ve been around this ecosystem for a while, this is a moment worth paying attention to. If you’re new, it’s a great time to join. The tools are catching up with the vision.
The future of the open web isn’t something we watch unfold — it’s something we build together.
<a href="https://www.youtube.com/watch?v=WNEyg3UKTVQ&amp;t=20s">Watch the keynote here →</a>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=a39cea480b1c" width="1" height="1" alt="">

What DrupalCon Vienna 2025 Made Me Realize About Drupal, AI, and the Future of the Open Web

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zg73cE2-bBwDeBE6tlTnWg.png"></figure>You’ve already got an SSH key (id_rsa) connected to one project — maybe your company repo or a client’s GitHub account. Now you need to clone another private repo, but you can’t risk overwriting that main key.
So what’s the move?
Let’s walk through how to use a different SSH key for Git clone safely and cleanly — no collisions, no broken auth.
<h3>Why This Happens</h3>
When you run:
<pre>git clone git@github.com:user/repo.git</pre>
Git uses your default SSH identity stored at ~/.ssh/id_rsa. If that key is already linked to a different GitHub or GitLab account, authentication fails or points to the wrong identity. That’s why you shouldn’t just replace your existing key — you need to add another one and teach Git when to use it.
<h3>Step 1: Create a New SSH Key for the Project</h3>
Run this command (replace projectX with something meaningful):
<pre>ssh-keygen -t rsa -b 4096 -C "your_email@example.com" -f ~/.ssh/id_rsa_projectX</pre>
<ul>
<li>-f sets the filename so you don’t overwrite your default key.</li>
<li>You’ll get two files:</li>
<li>~/.ssh/id_rsa_projectX (private key)</li>
<li>~/.ssh/id_rsa_projectX.pub (public key)</li>
</ul>
Add the public key to your GitHub/GitLab account for that specific project.
<h3>Step 2: Load the Key Using SSH Agent</h3>
Before cloning, start your SSH agent and add this new key:
<pre>eval $(ssh-agent -s) ssh-add ~/.ssh/id_rsa_projectX</pre>
This ensures the SSH agent knows which key to use when authenticating. If your terminal or container forgets keys between sessions, you’ll need to re-run these lines.
<h3>Step 3: Configure SSH to Use the Right Key Automatically</h3>
Open your SSH config file:
<pre>nano ~/.ssh/config</pre>
Add a custom block like this:
<pre>Host github-projectX HostName github.com User git IdentityFile ~/.ssh/id_rsa_projectX</pre>
Now, when you clone or push, use this alias instead of the regular GitHub domain:
<pre>git clone git@github-projectX:user/repo.git</pre>
Git sees github-projectX and automatically uses the key you assigned.
<h3>Step 4: Verify Your Connection</h3>
Test that your config works:
<pre>ssh -T git@github-projectX</pre>
If you see a greeting like “Hi username! You’ve successfully authenticated.” — you’re good to go.
<h3>Step 5: Optional — Manage Multiple Keys in One Session</h3>
If you switch between several repos often, you can list all loaded keys with:
<pre>ssh-add -l</pre>
And remove any that you don’t need:
<pre>ssh-add -d ~/.ssh/id_rsa_other</pre>
This keeps your agent clean and avoids confusion when you have many keys loaded.
<h3>Why Not Just Replace id_rsa?</h3>
Because it’s risky. If you overwrite your default key, every repo, server, or CI pipeline linked to that key breaks. Multiple SSH keys keep your work clean — one identity per project, one less headache later.
<h3>Quick Recap</h3>
<ul>
<li>
Problem: You can’t clone a repo because your default SSH key is already tied to another account.</li>
<li>
Solution: Create a new SSH key and configure it for that specific repo.</li>
<li>Command you’ll need:</li>
</ul>
<pre>eval $(ssh-agent -s) &amp;&amp; ssh-add ~/.ssh/id_rsa_projectX</pre>
<ul><li>
Bonus: Use ~/.ssh/config to make Git remember which key goes with which host.</li></ul>
<h3>Final Thought</h3>
You don’t have to juggle logins or overwrite your trusted key just to clone a new repo.
A little SSH configuration lets you keep things organized — every project gets its own door key, and you decide which one to unlock.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=98a22cf4a597" width="1" height="1" alt="">

How to Use a Different SSH Key for git clone (Without Replacing Your Main Key)

<h3>The Pain Every Developer Knows</h3>
Imagine this: a user checks out on your Drupal e-commerce site. Their order is created, but just as the system tries to update inventory, an error occurs.
<ul>
<li>The order is saved…</li>
<li>But the stock never decreases.</li>
<li>Now you’ve oversold.</li>
</ul>
Or worse — a form submission partially saves, leaving dangling records that confuse both users and admins.
These aren’t just bugs. They’re trust killers. And the scary part? They’re easy to miss until your clients call, furious about “missing” or “broken” data.
<h3>Enter Drupal’s Transaction API</h3>
<figure><img alt="drupal-transaction-api-database-security" src="https://cdn-images-1.medium.com/max/1024/1*hf5KEV-FToGfu-qu3aDRDQ.png"></figure>Drupal has a built-in safety net to prevent these nightmares: the Transaction API.
Think of it like a “group contract” for your database queries:
<ul>
<li>Either all queries succeed together
</li>
<li>Or none of them are applied
</li>
</ul>
No more half-saved records. No more inconsistent states. Just clean, reliable data handling.
<h3>How It Works (Simple Example)</h3>
Here’s a quick look at what using the Transaction API feels like:
<pre>&lt;?php $transaction = \Drupal::database()-&gt;startTransaction(); try { // Insert user $connection-&gt;insert('users') -&gt;fields(['name' =&gt; 'Dhruv', 'role' =&gt; 'Developer']) -&gt;execute(); // Log action $connection-&gt;insert('user_logs') -&gt;fields(['message' =&gt; 'New user created']) -&gt;execute(); } catch (\Exception $e) { // If anything fails, both inserts roll back \Drupal::messenger()-&gt;addError('Something went wrong: ' . $e-&gt;getMessage()); }</pre>
If one query fails, Drupal rolls back the entire transaction — leaving your database untouched and consistent.
<h3>When You Might Trigger a Manual Rollback</h3>
Normally, Drupal’s Transaction API handles rollbacks for you when an exception is thrown. But there are cases where you may want to force a rollback yourself — even if no PHP error occurs.
For example:
<ul>
<li>
Business Rule Violations The queries succeed technically, but the logic doesn’t. Say an order is created, but the product is out of stock. You’d rollback to avoid saving a “ghost order.”</li>
<li>
Validation Failures You insert a user, then later realize their email is invalid or their account didn’t pass a custom verification. Rolling back keeps your database clean.</li>
<li>
Conditional Checks A batch import may detect duplicate records during the process. Instead of half-importing, you rollback to retry or clean the data first.</li>
</ul>
<h3>Example</h3>
<pre>&lt;?php $transaction = \Drupal::database()-&gt;startTransaction(); try { // Insert order $order_id = $connection-&gt;insert('orders') -&gt;fields(['user_id' =&gt; 5, 'amount' =&gt; 250]) -&gt;execute(); // Check stock $stock = $connection-&gt;select('product_stock', 'p') -&gt;fields('p', ['quantity']) -&gt;condition('product_id', 10) -&gt;execute() -&gt;fetchField(); if ($stock &lt;= 0) { $transaction-&gt;rollback(); throw new \Exception('Order cancelled: insufficient stock.'); } } catch (\Exception $e) { \Drupal::messenger()-&gt;addError('Transaction failed: ' . $e-&gt;getMessage()); }</pre>
This way, you’re not waiting for the database to break — you’re proactively protecting it when business logic says “stop.”
<h3>Why It’s a Game-Changer</h3>
<ul>
<li>
Protects data integrity → No more partial saves.</li>
<li>
Reduces bugs in workflows → Especially in checkout, forms, and multi-table writes.</li>
<li>
Saves debugging time → You don’t chase ghost records anymore.</li>
<li>
Keeps users happy → Smooth, reliable experiences.</li>
</ul>
<h3>Where to Use the Transaction API</h3>
You don’t need it everywhere — but in the right places, it’s gold:
<ol><li>E-commerce Checkouts</li></ol>
<ul><li>Orders, payments, and inventory updates → must succeed together.</li></ul>
2. Bulk Operations
<ul><li>Imports or batch updates where a partial run would be messy.</li></ul>
3. Custom Entity Creation
<ul><li>Entities that span multiple tables.</li></ul>
4. Audit Logging
<ul><li>Ensuring logs match actual system changes.</li></ul>
<h3>Best Practices</h3>
<ul>
<li>Keep transactions short and focused (long ones block other queries).</li>
<li>Always wrap in try/catch for safe rollback.</li>
<li>Avoid unnecessary use for single queries.</li>
<li>Watch for deadlocks in high-concurrency systems.</li>
</ul>
<h3>Wrapping Up</h3>
Bugs from half-completed database operations are among the most frustrating for both developers and users. Thankfully, Drupal’s Transaction API makes these problems disappear.
So next time you’re building a checkout flow, batch operation, or anything critical — wrap your queries in a transaction. It’s one of those small things that separate good Drupal developers from great ones.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=1c7f3e3fce23" width="1" height="1" alt="">

️Never Lose Data Again: How Drupal’s Transaction API Saves Your Database

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wC1wTe995InD7RuuCUErGw.png"></figure>If you’re working with Drupal and the Masquerade module, you might find yourself needing to customize the “Switch back” link that appears when you masquerade as another user. This link allows you to return to your original user account after impersonating someone else — super handy for testing or debugging purposes. However, the default link might not always fit your site’s design or workflow. In this guide, I’ll walk you through how to create a custom switch back link using the Masquerade module in Drupal.
<h4>What is the Masquerade Module?</h4>
For those unfamiliar, the <a href="https://www.drupal.org/project/masquerade">Masquerade module</a> in Drupal lets administrators or privileged users temporarily “masquerade” as another user. This is great for seeing what a specific user experiences without needing their login credentials. By default, when you masquerade, Drupal provides a “UnMasquerade” link in admin menu to revert to your original account. But what if you want to tweak its appearance or behavior? That’s where customization comes in.
<h4>Why Customize the Switch Back Link?</h4>
You might want to:
<ul>
<li>Change the link text or styling to match your theme.</li>
<li>Move it to a different part of the page.</li>
<li>Add conditions for when it appears.</li>
<li>Replace it with a button or icon for a better UX.</li>
</ul>
Whatever your reason, Drupal’s flexibility combined with Masquerade’s hooks makes this totally doable.
Step-by-Step Guide
Setup your custom module which has dependency of masquerade plugin.
<ol>
<li>Create a custom module custom.info.yml.</li>
<li>Create custom module link menu file named as custom.links.menu.yml.</li>
<li>Final create the plugin file which will contain the code related to creating this custom link.</li>
</ol>
Path should be: /custom/src/Plugin/Menu/SwitchLink.php
<pre>name: Custom Masquerade type: module description: Customizes the Masquerade module switch back link. core_version_requirement: ^9 || ^10 || ^11 dependencies: - masquerade:masquerade</pre>
<pre>custom.unmasquerade: title: 'Switch Back' menu_name: main description: 'Switch back to your user account.' class: Drupal\custom\Plugin\Menu\SwitchLink weight: 2</pre>
<pre>&lt;?php declare(strict_types=1); namespace Drupal\custom\Plugin\Menu; use Drupal\Core\Config\ConfigFactoryInterface; use Drupal\Core\Database\Connection; use Drupal\Core\Entity\EntityTypeManagerInterface; use Drupal\Core\Extension\ModuleHandlerInterface; use Drupal\Core\Menu\MenuLinkDefault; use Drupal\Core\Menu\StaticMenuLinkOverridesInterface; use Drupal\Core\Plugin\ContainerFactoryPluginInterface; use Drupal\Core\Routing\RouteMatchInterface; use Drupal\Core\Session\AccountProxyInterface; use Drupal\masquerade\Masquerade; use Symfony\Component\DependencyInjection\ContainerInterface; /** * @todo Provide description for this class. * * @DCG * Typically a module-defined menu link relies on * \Drupal\Core\Menu\MenuLinkDefault class that builds the link using plugin * definitions located in YAML files (MODULE_NAME.links.menu.yml). The purpose * of having custom menu link class is to make the link dynamic. Sometimes, the * title and the URL of a link should vary based on some context, i.e. user * being logged, current page URL, etc. Check out the parent classes for the * methods you can override to make the link dynamic. * * @DCG It is important to supply the link with correct cache metadata. * @see self::getCacheContexts() * @see self::getCacheTags() * * @DCG * You can apply the class to a link as follows. * @code * foo.example: * title: Example * route_name: foo.example * menu_name: main * class: \Drupal\foo\Plugin\Menu\FooMenuLink * @endcode */ final class SwitchLink extends MenuLinkDefault implements ContainerFactoryPluginInterface { /** * Constructs a new AcUserSwitchLink instance. */ public function __construct( array $configuration, $plugin_id, $plugin_definition, private readonly RouteMatchInterface $routeMatch, private readonly AccountProxyInterface $currentUser, private readonly Connection $connection, private readonly EntityTypeManagerInterface $entityTypeManager, private readonly ConfigFactoryInterface $configFactory, StaticMenuLinkOverridesInterface $static_override, private readonly ModuleHandlerInterface $module_handler, private readonly Masquerade $masquerade, ) { parent::__construct($configuration, $plugin_id, $plugin_definition, $static_override); } /** * {@inheritdoc} */ public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition): self { return new self( $configuration, $plugin_id, $plugin_definition, $container-&gt;get('current_route_match'), $container-&gt;get('current_user'), $container-&gt;get('database'), $container-&gt;get('entity_type.manager'), $container-&gt;get('config.factory'), $container-&gt;get('menu_link.static.overrides'), $container-&gt;get('module_handler'), $container-&gt;get('masquerade') ); } /** * {@inheritdoc} */ public function getCacheContexts() { return ['session.is_masquerading']; } /** * {@inheritdoc} */ public function getRouteName() { if ($this-&gt;currentUser-&gt;isAuthenticated()) { return 'masquerade.unmasquerade'; } } /** * {@inheritdoc} */ public function isEnabled() { if ($this-&gt;currentUser-&gt;isAuthenticated()) { if ($this-&gt;module_handler-&gt;moduleExists('masquerade')) { if ($this-&gt;masquerade-&gt;isMasquerading()) { return TRUE; } } } return FALSE; } }</pre>
<h4>Conclusion</h4>
Customizing the Masquerade module’s switch back link is a straightforward way to improve your Drupal site’s usability and aesthetics. By leveraging Drupal’s hook system and Twig templating, you can create a seamless experience for users who need to masquerade. Try it out, tweak it to your liking, and let me know how it goes!
Happy coding!
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=6f51f8382e4a" width="1" height="1" alt="">

Creating a Custom Switch Back Link with the Masquerade Module in Drupal

<h3>DRUPAL DRUSH COMMAND DRUPAL 8 ,9 OR 10</h3>
In this Blog, We will review how to create custom commands in Drupal How do Drupal and Drush work together and what are the benefits? To enhance the productivity of your Development site. Since Drupal is a Content Management System (CMS), Drush is a Command Line Interface (CLI) tool used to maintain and update the Drupal configuration The most basic Drush commands provide to us are drush cr (clear cache), cex (config export),cim (config import) , status (Site status: Provide information about the site)
Note: Nowadays for Drupal 9 we are using Drush 11. Drupal 8.8.x above used Drush 10?
<h3>HOW TO CREATE DRUPAL DRUSH COMMAND</h3>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BeWBb0KIlh2Q-M_OsqiCww.png"></figure>Drush commands development on Drupal 9 is based on <a href="https://github.com/consolidation/annotated-command">Annotated command</a> format.
<h3>TREE STRUCTURE OF THIS MODULE:</h3>
<blockquote>Step 1</blockquote>
<h3>CREATE A MODULE.INFO FILE</h3>
In my case my module name is expteche_drush_command.info.yml
<pre>name: Expteche Drush Command type: module description: Create a custom Drush comand Drupal 9 package: expteche_custom core_version_requirement: ^9 || ^10</pre>
<blockquote>Step 2</blockquote>
<h3>CREATE A SERVICES YAML FILE</h3>
In my case my module name is drush.services.yml
<pre>services: expteche_drush_command.commands: class: \Drupal\expteche_drush_command\Commands\ExptecheDrushCommandCommands tags: - { name: drush.command }</pre>
<blockquote>Step 3</blockquote>
<h3>CREATE A CLASS FILE FOR THE DRUSH SERVICE</h3>
I have created a PHP class ExptecheDrushCommandCommands.php file for the Drush command definition.
<pre>&lt;?php</pre>
<pre>namespace Drupal\expteche_drush_command\Commands;</pre>
<pre>use Consolidation\OutputFormatters\StructuredData\RowsOfFields; use Drush\Commands\DrushCommands;</pre>
<pre>/** * A ExptecheDrushCommandCommands. */ class ExptecheDrushCommandCommands extends DrushCommands {</pre>
<pre> /** * Command description here. * * @param $message * Argument description. * @param array $options * An associative array of options whose values come from cli, aliases, config, etc. * @option status * status : Site status * @usage expteche_drush_command:message Welcome to exptechestatus * Usage description * * @command expteche_drush_command:message * @aliases exp_message */ public function print($message = 'Default message', $options = ['custom' =&gt; false]) { if ($options['custom']) { $this-&gt;logger()-&gt;log('notice',dt('Implementing Custom code')); # code return true; } return $this-&gt;logger()-&gt;log('success',dt('Message: @msg',['@msg'=&gt;$message])); }</pre>
<pre>}</pre>
<blockquote>Output</blockquote>
Image
<figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*LRGFaGBqOgnxpeR9"></figure>Hope you find this article useful. If yes, please let me know in the comment section
Enjoy your day. Happy Coding
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=5e1f9291743f" width="1" height="1" alt="">

Notes from the Drupal desk.