Ask this question in any Salesforce Slack group or community thread and watch what happens. Within an hour, you’ll have two answers, both delivered with total confidence, and they’ll flatly contradict each other. One person swears you’re not a real architect until you’ve shipped Apex to production. The next insists the best architects they know barely open the developer console.
If you’re an admin or consultant eyeing the architect track, that contradiction isn’t just annoying. It’s also quite expensive. If you follow the first group’s advice, you might end up spending the next year grinding through Apex tutorials you may not even need. Conversely, if you follow the second group’s advice, you might overlook a skill that actually turns out to be a hard requirement.
So let me give you the straight version, with the certification facts laid out plainly: you don’t need a developer job, but you do need enough code fluency to pass one very real developer exam.
Key takeaways
- You don’t need a developer job title to become a Salesforce architect, but you do need genuine code literacy.
- Salesforce enforces that literacy through certification: Platform Developer is a required component of both the Application Architect and System Architect designations, and both are prerequisites for CTA.
- The Platform Developer exam is heavily programmatic. Expect mostly code-reading scenarios, and budget study time if you’re coming from a pure admin background.
- The skill that matters is judgment: knowing where declarative tools stop and code has to take over. Salesforce’s own decision guides draw that line.
- “Enough” means you can read a trigger, reason about it, and scope work with developers. It does not mean writing production code daily.
Table of Contents
What “technical” really means for an architect
Half the confusion here comes from a specific term. When people say that an architect needs to be “technical,” most of us interpret that to mean they must spend their entire day writing code. But that is not what this role actually demands.
For an architect, being ‘technical’ means understanding the trade-offs, limits, and downstream consequences of every tool on the platform well enough to pick the right one. It means knowing what a Flow can’t do that a trigger can. It means walking into a design conversation with developers as a peer, scoping real work, instead of handing them a vague wish and hoping.
Salesforce says as much in its own description of the role. Its guide to what a Salesforce architect is lists “code literacy” as a core skill, which it defines as the ability to read code and recognize coding best practices to guide development teams. Then it adds the line the “you need Apex” crowd always skips: architects “do not need to be a developer.”
The same page places architects on a spectrum, from Solution Architects on the functional end to Technical Architects on the technical end. Where you land on that spectrum changes how much code you touch. It doesn’t change the job’s underlying truth. The strongest architects I’ve worked with weren’t the ones with the single deepest skill. They were the ones who understood enough to make the right choice.
The Certification path settles the argument
Here’s where opinion stops mattering, because Salesforce has already decided for you. The official architect path includes a developer requirement, and many online guides get this part wrong. They list retired “Designer” credential names, or they leave the developer exam off the component list entirely.
So let’s get it straight, using the current names (Salesforce renamed 35+ certifications in July 2025, which is why the labels may look unfamiliar). Neither architect designation is a single exam you sit. Each one is a composite: you earn it by clearing a set of component certifications. Here’s what rolls up into each.
| Designation | Component certifications | Separate exam? |
|---|---|---|
| Application Architect | Platform App Builder, Platform Data Architect, Platform Developer, Platform Sharing and Visibility Architect | No, granted when all four are done |
| System Architect | Platform Developer, Platform Development Lifecycle and Deployment Architect, Platform Identity and Access Management Architect, Platform Integration Architect | No, granted when all four are done |
| Certified Technical Architect (CTA) | Both designations above, then a live Review Board | Yes, a two-part board |
Notice the name that shows up on both rows.
What rolls up into Application Architect
Four component certs: Platform App Builder, Platform Data Architect, Platform Developer, and Platform Sharing and Visibility Architect. There’s no separate Application Architect test. Clear all four, and the designation is granted automatically. The detail worth sitting with: App Builder (the declarative exam) and Platform Developer (the programmatic one) sit side by side here on purpose. Salesforce wants you fluent in both clicks and code.
What rolls up into System Architect
Again, four components: Platform Developer, Platform Integration Architect, Platform Identity and Access Management Architect, and Platform Development Lifecycle and Deployment Architect. This side leans toward the off-platform concerns, integrations, identity, and release governance. And there it is again: Platform Developer. It’s the one exam that appears on both tracks, making it the single certification every aspiring CTA must pass, no matter which end of the spectrum they come from.
And CTA sits on top of both.
The Certified Technical Architect is still the summit, and it still runs through a live board, not a multiple-choice test. To even qualify, you need both the Application Architect and System Architect designations in hand. After that comes a two-part review: an Architect Review Board Evaluation (US$1,500) and then the Technical Architect Review Board Exam (US$4,500). That’s $6,000 on a first attempt, before you count the component exam fees underneath. Registration now lives in Trailhead Academy, not the old Webassessor portal.
CTA isn’t the focus of this article. I mention it only because it proves the point: the code requirement doesn’t fade as you climb. It runs all the way to the top.
So how much of the Platform Developer exam is actually code?
This is the question that’s really keeping you up at 11 p.m., so let’s answer it with the actual exam facts rather than vibes.
The Platform Developer exam has 60 multiple-choice questions and up to five unscored questions, 105 minutes, and a 68% passing score. Salesforce pitches it at someone with roughly one to two years of development experience and at least six months on the platform. The current objective weightings break down like this:
- Developer Fundamentals: 27%
- Process Automation and Logic: 28%
- User Interface: 25%
- Testing, Debugging, and Deployment: 20%
Read the published objectives, and the shape of it becomes obvious. You’re asked to “assess how Apex control flow statements will execute,” to “write SOSL, SOQL, and DML statements in Apex, and assess what they will return,” and to understand governor limits and their effect on Apex transactions. These aren’t configuration questions dressed up in developer language. They test whether you can look at a block of Apex and correctly predict what it does.
Here’s my own read, and I’ll flag it clearly as SalesforceTrail’s analysis rather than a Salesforce figure: of the 20 published objectives, around 13 are explicitly programmatic, covering Apex, SOQL and DML, Lightning Web Components, test classes, and deployment. A couple lean declarative. The rest are mixed.
So what does that mean for you? You can absolutely pass this without being a full-time developer. People do it every cycle. But an admin who has never opened the developer console and never written a line of Apex should go in expecting most of the exam to be code-reading scenarios, and should budget real study time accordingly—no shortcuts around that one.
Where “clicks, not code” actually breaks down
Now for the part that explains why Salesforce bothers testing code literacy at all. The whole “clicks, not code” philosophy is sound right up until it isn’t, and knowing exactly where that line falls is the judgment an architect gets paid for.
Salesforce’s own Record-Triggered Automation decision guide is the clearest map of where Flow hits a wall, and Apex has to take over. A few of the hard limits it calls out:
- Transaction control. Flow gives you no access to savepoints, rollbacks, or partially successful DML. When you need real transaction control, that’s Apex territory.
- Data structures. Flow has no native Map or Set, which makes genuinely complex data processing clumsy and inefficient.
- Bulk processing. Push real bulk volumes through Flow, and you’re at elevated risk of hitting governor limits. The guide flags this directly.
- Undelete and advanced functions. Record-triggered Flow doesn’t support the after-undelete context, and Apex exposes library functions (like Crypto and BusinessHours) that declarative tools don’t.
The guide even offers a rough density rule of thumb for when to graduate from Flow to code:
| Automation density | Automations per object | Records per transaction | Recommended approach |
|---|---|---|---|
| Low | Under 15 | 1 to 200 | Record-Triggered Flow |
| Medium | 15 to 30 | Moderate batch | Flow plus invocable Apex |
| High | Over 30 | 2,000 to 10,000+ | Apex trigger framework |
I don’t want this to read as anti-Flow, because it isn’t. The same guide rates Flow as the recommended choice for speed of delivery, governance visibility, email alerts, and scheduled paths, the last of which an Apex trigger can’t even do natively. The point is simpler than “code good, clicks bad.” An architect’s job is to make this call correctly, every time. And you cannot make it if you can’t read what the trigger actually does.
How much developer literacy is enough, and where it stops mattering
The fear underneath this whole question is usually: how do I build just enough coding skill without accidentally wandering into a developer career I never wanted? Fair concern. Here’s the honest bar.
‘Sufficient’ means something like this: You can look at a trigger and anticipate its behavior. You can identify an SOQL query embedded within a loop and understand why it presents a problem. You know when a solution exceeds the limitations of ‘Flow’ and requires ‘Apex’. You understand the language well enough to define the scope of work with a developer and review their ‘pull requests’ at a high level, without needing to examine them line by line.
It is equally important to know where the significance of these things ends. You do not need to write ‘bulk-optimized,’ production-grade Apex classes daily. You do not need to optimize complex Lightning Web Components. Nor do you need to spend all your time working on test frameworks. These are developers’ responsibilities, and it is perfectly fine to stay away.
If you want reassurance that this balance is real, look at how working architects actually rank their skills. In community surveys of architects, coding consistently lands near the bottom of the “most valuable skill” list, with communication at the top, yet the overwhelming majority of architects still do some hands-on work. Read those two findings together, and you get the whole answer in one line: code is table stakes, not the main event.
A realistic admin-to-architect path
If you’re coming from the admin side, here’s a sequence that respects where you already are and eases you toward the code without a cold plunge.
- Start with Platform App Builder. It’s declarative home turf. You’ll clear it on skills you mostly already have, and it builds momentum before anything harder.
- Take Platform Developer next, and don’t just cram for it. Work through Salesforce’s official cert-prep material, then do the one thing that actually makes Apex click: build a real trigger and a real test class yourself, in a dev org. Reading about Apex and writing twenty lines of it are different experiences, and the exam rewards the second.
- Round out Application Architect with Sharing and Visibility Architect and Data Architect. Now you hold a full designation.
- Layer in the three System Architect domain exams as the work in front of you demands them, rather than all at once for the badge.
A couple of practical notes. This is a multi-year journey for most people, not a quarter’s work, so pace it against real projects. And keep an eye on maintenance: Salesforce requires periodic maintenance modules to keep architect-track credentials active, so a cert you earned isn’t a cert you keep automatically.
One more thing, said plainly: there’s no shame in stopping at Application Architect. Plenty of excellent, well-paid architect careers never touch the CTA board. Chase it because you want it, not because you think the title is incomplete without it.
Mistakes to avoid
- Treating code as all-or-nothing. The trap is thinking you either become a developer or you avoid code forever. The actual target is a narrow band of fluency: read it, reason about it, scope it. Overshoot and you waste a year; undershoot, and you fail Platform Developer.
- Trusting outdated cert maps. A lot of roadmaps floating around still use retired “Designer” names or drop Platform Developer from the component list. If a guide doesn’t show the developer exam on both tracks, it’s out of date.
- Cramming Platform Developer without touching an org. You can memorize syntax and still freeze on a code-reading scenario. Build something small and real before you sit the exam.
- Chasing CTA before you want it. The board is expensive and demanding. Earn it because the work calls for it, not out of a nagging sense that a lesser title doesn’t count.
Final Thoughts
Stop debating the question in the abstract and go find out where you actually stand. Spin up a free Developer Edition org, open the developer console, and write one trigger that updates a field on a related record, plus a test class to cover it. Give it an afternoon.
If that exercise feels doable, even if it’s slow and you’re googling every step, you have the aptitude to clear Platform Developer and keep climbing. If it feels genuinely impossible, that’s useful information too: it tells you exactly where to put your study time before you book the exam. Either way, you’ll know something concrete instead of arguing about it online.
That’s the architect mindset in miniature. Test the trade-off yourself, then decide.
Frequently Asked Questions
Not entirely. You don’t need to work as a developer, but you can’t earn the Application Architect or System Architect designation without passing Platform Developer, which tests your ability to read and reason about Apex. Code literacy is required; a coding job is not.
Some do; many don’t, day to day. The role is about deciding when Apex is the right tool, not producing it on a schedule. In architect community surveys, the vast majority still do some hands-on work, but coding ranks low among the skills they consider most valuable.
Yes. The exam is now simply called Platform Developer (renamed from Platform Developer I in 2025), and it’s one of the four component certifications that make up Application Architect. It’s also required for System Architect.
Enough to read a trigger and predict what it does, spot inefficient SOQL, understand governor limits, and scope work with developers. You don’t need to write production-grade Apex daily. The bar is fluency, not mastery.
Yes, and it’s a common path. The main gap to close is developer literacy. Start with Platform App Builder, then work toward Platform Developer, including writing a real trigger and test class so Apex stops feeling abstract.
For many people, yes. Architect roles sit at the senior end of the ecosystem and pay accordingly, and demand for technical architect skills has held up well. Just go in clear-eyed about the multi-year certification journey involved.

Arun Kumar
Arun Kumar is a 4x Salesforce Certified professional. He designs and implements scalable solutions that improve customer engagement, streamline business processes, and drive measurable results. Passionate about exploring the latest Salesforce innovations, Arun enjoys sharing practical insights and best practices to help businesses build smarter, data-driven strategies.
- Arun Kumar











