I'm sitting for the PD1 exam in about 5 weeks and I'm trying to calibrate how deep the implementation questions go. My practice scores are hovering around 67-70% and the passing score is 68%, so I'm right on the line and I need to understand where to put my final prep time. I've been developing in Salesforce for about 2 years, mostly on back-end automation and integration work.
The sections where I'm losing points are Apex triggers and governor limits questions. I understand the concepts - one trigger per object, bulkification patterns, the 150 DML limit - but the exam scenarios involve edge cases I haven't hit in real work. Things like recursive trigger prevention and order of execution in complex org setups. My SOQL and Visualforce sections are much stronger, probably 80%+ on those.
I'm not worried about the declarative vs. programmatic distinction questions or the security model stuff - those feel solid. It's really the Apex execution context and asynchronous processing sections dragging my average down. Should I prioritize batch Apex and future methods over the trigger patterns, or is the trigger content weighted more heavily?
67-70% on practice exams 5 weeks out is tight but workable. I was at 65% at the 4-week mark and passed with a 71%. Double down on your weak sections instead of maintaining your strong ones - your SOQL knowledge isn't going anywhere.
For the edge cases you haven't hit in real work, Trailhead has a specific module on trigger frameworks and bulkification that walks through exactly the scenarios the exam loves. Do it twice and actually run the code in a dev org rather than just reading it.
Triggers and governor limits are probably 20-25% of the exam on their own. The recursive prevention pattern and order of execution show up as scenario questions, not just definitions, so you need to be able to trace through them mentally rather than just recognize terms.
Batch Apex gets tested more than most people expect. Know the Database.Batchable interface cold - the start, execute, and finish methods and what scope means in that context. It comes up as implementation code reading, not just conceptual questions.
I was in almost the exact same spot three months ago and what clicked for me was spending less time on flashcards and more time dissecting why the wrong answers are wrong. For trigger edge cases specifically, the exam loves to give you two answers that both sound plausible, and if you've only memorized the "right" pattern you'll second-guess yourself. When I started writing out one sentence explaining why each distractor was wrong, my score jumped about 8 points in two weeks. It's tedious but it's the difference between recognizing a concept and actually understanding it.
On depth, they're not asking you to write recursive trigger logic from scratch, but they will absolutely test whether you know what happens when a trigger fires in bulk context versus a single-record DML, and why order of execution matters for validation rules. Didn't think that stuff would show up but it did for me. If you're at 67-70% you probably already know the happy path, so drilling the "what goes wrong and why" scenarios is where your remaining five weeks should go.
I was in almost the exact same spot two months ago, sitting around 68-69% and stressing out. What actually moved the needle for me wasn't grinding more questions — it was going back through every wrong answer and asking myself why the other three options were wrong, not just why the right one was right. For trigger edge cases specifically, the PD1 questions aren't usually asking you to write code from memory; they're testing whether you understand execution order, recursion prevention, and what happens when you mix before/after contexts incorrectly. Once I started thinking about it that way, patterns clicked fast.
The area that surprised me most was testing and debugging — I'd underestimated it completely. Spending time on pd1 testing and debugging practice really helped me see how Salesforce frames those scenarios, and it's where a lot of edge case logic actually shows up in disguise. At 67-70% you're probably missing a few key conceptual gaps rather than needing a broad review, so I'd chase down your wrong answers hard this last stretch rather than trying to cover everything again.
I passed PD1 back in March and honestly the thing that got me off the bubble was exactly what you're describing. When I was scoring 68-70% on practice tests I stopped reviewing just the questions I missed and started forcing myself to explain why every wrong option was wrong, even on questions I got right. Sounds tedious but it changed everything. The trigger questions especially love to give you three answers that all "work" and one that works correctly, like an option that updates records in a before trigger with DML when you should just modify Trigger.new directly. If you can't articulate why the DML version is wrong, you'll fall for it on a slightly reworded question later.
The real exam didn't go super deep on obscure edge cases, but it absolutely tested whether you understood bulkification and order of execution versus just recognizing patterns. I'd guess a third of my wrong practice answers were me picking something plausible without knowing why the distractor was a trap. Five weeks is plenty. Spend it on the why, not on more reps.
I passed in June after being stuck right around where you are, and the thing that finally moved my score wasn't more practice tests, it was changing how I reviewed them. Every question I missed, I made myself explain why each wrong answer was wrong, not just why the right one was right. That's where the trigger stuff clicked. The exam doesn't go crazy deep on edge cases, but the wrong answers are built from real misconceptions, like thinking a trigger fires once per record or that you can update Trigger.new in an after context. If you can articulate why those are wrong, you'll spot the trap instantly instead of second-guessing.
For the last few weeks I'd drill with flashcards on order of execution and governor limits, but I'd flip each card and ask myself what a plausible wrong version would look like. Sounds tedious. It's not, it's fast once you get going, and at 67-70% you're probably losing points to distractors, not to gaps in actual knowledge. Two points is like three questions. You've got this.