If the Developer Console has disappeared from the gear menu in your org, nothing is broken. Since the Winter '27 release, Salesforce hides the Developer Console by default and shows its new Web Console instead. An administrator can turn the Developer Console back on in about a minute.
The quick fix (admins):
- Go to Setup and type Development in the Quick Find box.
- Select Web Console.
- Switch Enable Developer Console to Active, then reload the page.
The Developer Console then reappears in the gear menu. If you are not an administrator, or if that setting is not there, read on: there are four other reasons the Developer Console may not be visible, and each has a different fix.
Why the Developer Console is not visible: five causes
Work down this list. The first cause is by far the most common since October 2026.
1. Winter '27 turned it off by default
Salesforce's Winter '27 release note says the Developer Console option "is not visible by default in Setup". Salesforce now presents the Web Console, a browser IDE built on VS Code for Web, as the replacement for the Developer Console and for Workbench.
The Developer Console has not been removed. It is switched off. The fix is the three steps above. Two details from the release note:
- If both consoles are set to Active, both appear in the Setup menu.
- If the Web Console is set to Inactive, the Developer Console turns on by default and the standard Setup buttons come back.
Only an administrator can change this. Salesforce's guide says individual users cannot enable or disable the Web Console, or change the default IDE, for themselves.
2. Your user is missing a permission
This cause predates Winter '27. Salesforce's Open the Developer Console article lists the permissions it needs:
| To… | You need |
|---|---|
| Use the Developer Console at all | API Enabled and View All Data |
| View, keep and delete debug logs | View All Data |
| Run a SOQL or SOSL query, or search code | API Enabled |
| Execute anonymous Apex, or save Apex classes and triggers | Author Apex |
| Save Visualforce pages, components or Lightning resources | Customize Application |
If a colleague can see the Developer Console and you cannot, compare your profile and permission sets against the first row. View All Data is a powerful permission, so many orgs rightly keep it from most users. An admin may prefer to grant it only through a permission set assigned for a limited time.
3. You are looking in the wrong menu
Where the Developer Console lives depends on which interface you use:
- Lightning Experience: the gear icon (Salesforce calls it the quick access menu) at the top right, then Developer Console.
- Salesforce Classic: click your name, then Developer Console.
People who move from Classic to Lightning often look under their profile picture, where it has never been.
4. Your edition does not include it
Salesforce lists the Developer Console for Enterprise, Performance, Unlimited, Developer and Database.com editions. If your org is on another edition, such as Professional Edition, it may never have been there.
5. You are on Government Cloud
Salesforce has a known issue, W-24041529. After Government Cloud preview sandboxes upgrade to Winter '27, neither console appears. The Web Console feature is switched off there, so the setting from the quick fix does not exist. When we checked on 14 October 2026, its status was still "Solution Scheduled".
Salesforce lists two workarounds:
- Switch to Salesforce Classic and open the Developer Console from the user menu.
- Add
/_ui/common/apex/debug/ApexCSIPageto the end of your org's My Domain URL, for examplehttps://yourdomain.my.salesforce.com/_ui/common/apex/debug/ApexCSIPage.
If neither works, Salesforce Support says it may be able to apply a workaround to your org.
If you are not an admin: what to ask for
Send your Salesforce admin something like this:
Since Winter '27 the Developer Console is hidden by default. Could you check Setup → Web Console → Enable Developer Console and set it to Active? If it is already active, I may be missing the API Enabled or View All Data permission.
That covers causes 1 and 2, which account for nearly every report.
Should you switch it back on?
For most teams, yes, for now. We could not find a retirement date for the Developer Console in the release note or the developer guide. But Salesforce is clear about where it is heading, so treat the switch as a bridge while you choose what comes next.
Salesforce publishes its own comparison of the two consoles. In short (our Developer Console vs Web Console post goes task by task):
| Developer Console | Web Console | |
|---|---|---|
| Metadata types | Apex, Aura and Visualforce | All metadata types |
| Lightning Web Components | Not supported | Supported |
| Debug logs | Richer log views, and you can open the source from a log | Logs shown as raw text unless you add tools |
| Project context | None | Kept, with in-context editing |
| Interface | Its own layout | Similar to VS Code |
Before you switch the Developer Console off for good, test two things. Logs: if you spend much time in the Developer Console's log views, try the Web Console on a real log first, because Salesforce's own comparison credits the Developer Console with the richer views. Production: the Web Console keeps Apex read-only in production orgs. You can inspect code there but not change it.
Also worth knowing: the Web Console's extensions come prepackaged, so you cannot add others from the Visual Studio Marketplace, and Salesforce says Professional Edition orgs get restricted access.
The bigger change: from consoles to agents
Both consoles share one assumption: you do the work. You open the class, read the log, write the query, find the line that broke and fix it. The tool waits for you.
That is the part AI is changing. An agentic tool does not wait for you to find the problem. You describe the outcome, and it investigates your org, reads the evidence, makes the change and checks the result. You stay in charge of what reaches the org.
That is what we built the orgadmin.ai Development Studio to do. It runs in the browser, connects to your orgs, and works with the AI provider you choose.
What an agentic loop looks like in practice
Take a request that would mean an afternoon in the Developer Console: "Fix this deployment. Two test classes are failing."
- It finds the failure itself. The AI lists recent deployments for the org and pulls the compile errors and Apex test failures for the one that failed, with component names, line numbers and assertion messages. These are Salesforce's own errors, not a guess.
- It reads the evidence. It opens the failing test classes and the code under test, describes the objects and fields involved, checks the automation on those objects, and runs SELECT-only SOQL against live data if it needs to.
- It edits in place. Instead of pasting back a whole new file, it changes the exact lines that need to change in your project, so you can see what moved.
- You validate or deploy. You press the button, pick the test level, and choose the target. In a sandbox you can deploy directly. Against production the default is a check-only validation, and a real deployment needs an extra confirmation.
- It reads the result and goes again. If the run fails, the new errors come back to the AI, and it works from them.
The same loop handles new work: "Write a batchable Apex job that archives closed cases older than two years", or "Build an LWC datatable of open opportunities with inline stage editing". Before it writes anything, the AI looks at your real schema and existing code, and it follows built-in playbooks for Apex, Lightning Web Components, flows and permission sets.
Where it goes further than a console
| You used the Developer Console to… | The Developer Console | orgadmin.ai |
|---|---|---|
| Edit and save a class | You edit, Salesforce compiles on save | The AI drafts or edits, you review. A scratch editor saves straight to a sandbox. Projects keep versions with diffs and restore. |
| Fix a failed deployment | You read the errors and hunt for the line | The AI pulls the failures and fixes the lines they point at |
| Run SOQL | You write the query | The SOQL console builds the query from plain English. Results are live and capped at 5,000 rows, and saved queries are shared with your team |
| Read a debug log | You scroll the log | Debug Logs analyses up to five related logs for exceptions, slow SOQL and DML, and limit use |
| Move a change between orgs | Not possible | Projects deploy as one package. Validate against production first, then quick-deploy the validation that passed |
| Use your own AI tools | Not possible | The MCP server gives Claude Code, Codex, Cursor or Claude Desktop the same org tools, permissions and audit log |
That last row matters if you already use an AI coding agent. Through MCP, your agent can describe objects, read Apex and flows, run SELECT-only queries, build Development Studio projects and read why a deployment failed. It works under the same workspace roles as the web app, and the AI usage runs on your own subscription.
The guardrails
Agentic should not mean unattended. These are deliberate:
- The AI never deploys by itself, in the app or over MCP. A person starts every deployment and every validation.
- Production needs a confirmation for each run, and the default is a check-only validation.
- Write access is off unless you turn it on. Writes need the "Deploy & write" permission. MCP tokens start read-only, and you add scopes deliberately.
- The scratch editor's save-on-compile is sandbox-only and limited to workspace owners and admins.
What it does not do
If the Developer Console is your main debugging tool, know the gaps before you move:
- No execute anonymous Apex, and no checkpoints or heap inspection.
- No standalone test runner. Tests run as part of a validation or deployment, at the level you choose.
- No git, Salesforce CLI or scratch orgs. For a source-driven pipeline, the Agentforce Vibes IDE or VS Code with the CLI is the better fit.
- No trace flags. You still set those in Setup. Debug Logs reads and analyses the logs they produce.
- It needs a desktop-sized window.
How to choose
- You just need the Developer Console back: turn it on in Setup (above) and keep both consoles active while you decide.
- A small fix in a sandbox, no AI needed: the Web Console, which is free in all supported editions.
- Multi-file feature work with git and scratch orgs: the Agentforce Vibes IDE, which Salesforce's release note calls a paid tool, or VS Code with the Salesforce CLI.
- An AI that investigates your org, makes the change, reads the real errors and iterates, with review and promotion between orgs and nothing to install: the orgadmin.ai Development Studio.
- Checkpoints, test suites or the Log Inspector's views: keep the Developer Console switched on. (Anonymous Apex is in both consoles, per Salesforce's Web Console FAQ.)
What to do this week
- Turn the Developer Console back on if your team relies on it, and tell people where both consoles live.
- Check permissions for anyone who still cannot see it: API Enabled and View All Data.
- Try your three most common Developer Console tasks in the Web Console, starting with logs, in a sandbox.
- Give an agent a real task. Start a free orgadmin.ai trial, connect a sandbox rather than production (the first 15 minutes guide shows how), and hand the Development Studio the last bug you fixed by hand. Compare the time.
Sources and further reading
- Web Console (Salesforce Winter '27 Release Notes)
- Open the Developer Console (Salesforce Help: required editions and permissions)
- Enable Web Console and the Web Console FAQ (Salesforce Developers)
- Developer Console vs Web Console and Web Console vs Agentforce Vibes IDE (Salesforce Developers)
- Developer Console/Web Console Missing in Winter '27 GovCloud Preview Sandboxes (Salesforce Known Issues, W-24041529)