I turn messy processes into
I design Flow, Apex and Agentforce systems that remove friction, make decisions explicit and give teams a process they can trust.
PROCESS ▸ Map ownership, decisions and exceptions.
state initialized
deterministic rules
correlation persisted
guardrails active
Every fault audited
no silent failure paths
One result per input
deterministic contract
One process. Three focused builds.
These interactive simulations share the same synthetic Request-to-Resolution process. Together they show how I choose the right automation layer and connect the pieces safely.
Automation starts with the process, not the tool.
Explore how an unowned request becomes a traceable path with explicit decisions, controlled exceptions and a safe human handoff.
Intake
Incomplete requests enter through inconsistent channels.
Decision
Routing knowledge lives in people and sprawling automation.
Exception
Failures disappear into inboxes or silent fault paths.
Handoff
The next owner has to reconstruct the context.
Normalize
Flow validates the request and sets a clear automation state.
Route
Apex applies deterministic metadata-driven rules in bulk.
Observe
Correlation IDs and audit events make every outcome traceable.
Assist
Agentforce guides, confirms and escalates inside defined guardrails.
Make the standard path obvious.
Use Flow for visible orchestration, reusable paths and business logic that administrators can understand without sacrificing fault handling.
Move complexity behind a clear contract.
Use bulk-safe Apex where branching, matching and testability would make a Flow harder to trust, then return a result Flow can act on.
Give agents narrow, safe actions.
Ground guidance in approved knowledge, require confirmation before writes and preserve a human path for sensitive or uncertain requests.
A continuous audit log with correlation identifiers makes every automation outcome traceable.
Escalation is a successful outcome.
For sensitive or uncertain work, a context-rich human handoff is safer than forced autonomy.
From friction to a system your team can operate.
Start with the process, choose the smallest useful engagement, and leave with decisions your team can maintain.
Process & Automation Audit
Turn an unclear process and a crowded org into a decision-ready automation blueprint.
- Current-state process and automation map
- Bottlenecks, ownership gaps and failure risks
- Prioritized Flow / Apex / Agentforce / do-not-automate backlog
- Production hardening recommendations
Best for
Teams that need clarity before adding another automation.
Flow / Apex Rescue
Refactor fragile automation into a maintainable system with explicit contracts and observable failures.
- Before-and-after architecture
- Focused Flow and Apex implementation
- Fault paths, audit trail and recovery guidance
- Test scenarios and handover documentation
Best for
Teams dealing with brittle flows, routing edge cases or unclear ownership.
Agentforce Pilot
Prove one valuable agent workflow with grounded guidance, narrow actions and deliberate guardrails.
- Use-case and risk boundary
- Topic, instructions and approved knowledge design
- Flow / Apex actions with confirmation and escalation
- Evaluation scenarios and pilot readout
Best for
Teams that want a controlled Agentforce use case before wider adoption.
See the thinking before the build.
Review the Process Blueprint as an accessible web page or download the eight-page PDF.
Map → Decide → Build → Harden
The same operating loop for every engagement: make the process visible, choose the right layer deliberately, ship the smallest end-to-end slice, then make it safe to run.
- 01
Map
Make the real process, owners, inputs, exceptions and desired outcome visible.
- 02
Decide
Choose Flow, Apex, Agentforce or no automation for each responsibility.
- 03
Build
Implement the smallest end-to-end slice with explicit interfaces and testable outcomes.
- 04
Harden
Add failure handling, security, observability, scale tests and a clear human fallback.
Kacper Walat · Salesforce automation engineer
An operator's approach to Salesforce automation.
I design automation as a system: process first, the simplest suitable tool second, and operability from the start.
My work focuses on clear ownership, testable decisions and safe failure modes across Flow, Apex and Agentforce.
- Focus
- Process automation on Salesforce
- Stack
- Flow · Apex · Agentforce
- Principle
- Simplest suitable tool, operable from day one
Practical decisions behind reliable automation.
Short technical guides for teams that want automation they can understand, test and operate.
Let's map the friction and choose the right automation layer.
A focused conversation about the process, automation risk and the most useful next step — no polished brief required.