Index
A
Apex
Apex/visualforce/lightning
GitHub account
phase checklist
phase F standards
programmatic resources
API documentation
API Interface Specification
Application architecture
advantage
areas
complexity
definition
developers/app builders
files/social
formal method
formulas
general architecture
apex batch element
AppExchange components
coexistence
context
customization
data access
data models
data ownership
data types/sizes
discrepancies
duplicating existing functionality
goal
integration
key points
licensing
maintenance
objects
platform limits
programmatic functionality
project’s longevity
record types
relationships
reporting strategy
resources
testing
URL field type
governance level
governance team
inputs
integration architecture
localization/global deployments
Salesforce platform
scenario
steps
files/social
formulas
general architecture
localization/global deployments
outputs
workflow/process
stock control system
technical options
whitelist approach
workflow/processes
Aura-based components
Automation
B
Batch Data Synchronization
Branching
C
Call-in integration pattern
Central governance
Certified technical architect (CTA)
Checklist
Client-side integration
Communities
design
license types
mobile
project team
business requirement
sharing model
sharing options
sharing requirements
UI /UX updates
users
Continuous integration and continuous deployment (CI/CD) pipeline
Customer-centric strategy
Customer Community
Customer relationship management (CRM)
Custom field
Custom labels
Custom objects
Custom settings
D
Data architecture and management
approach
areas
conceptual data model
data aspects
data governance
data movement
definition
design and optimization
AppExchange packages
capacity model
complexity
considerations
create model
cross-org
custom field
custom metadata
custom objects
data integrity
data model
data visibility
divisions
duplication
external data/objects
governance body
governance levels
governing
hierarchical settings
indexes
project’s application scale
RDBMS
relationships
reports
scale of data
sources
transaction boundaries
design decisions
feedback
formal method
governance team
Hanna’s model
inputs
logical data model
optimization
outputs
physical data model
potential issues
scenario
standards
steps
Data Manipulation Language (DML)
Data model
checklists
custom settings
fields
objects
Data movement
Data Virtualization integration
Data warehousing strategies
Declarative sharing
account relationship data sharing
dashboard folder security
design
external account hierarchy
groups
sets
super user access
territory management
user types
enhanced folder sharing
features
manual sharing
OWDs
permission set-level object setting
profile-level object setting
record ownership
implicit sharing
legacy folder sharing
list view security
master–detail relationship
report folder security
team functionality
account/case/opportunity
manager groups
queues
role hierarchies
Deployment techniques
CI/CD pipeline
tools
Description fields
Developers
Development lifecycle
branching
CI/CD pipeline
environment responsibilities
environments
multiple project teams
release of applications
testing/test plan
tools
Development Lifecycle & Deployment
automated testing
checklist
resources
standards
tools
Duplication rule
E
Employee Community
Enterprise Object
Enterprise solution architecture (ESA)
Enterprise vs. salesforce integration patterns
Experience cloud
communities
customer service portal
phase checklist
phase G standard
resource base documentation
resources
UX/UI
External objects
Extract, transform, and load (ETL) process
F
Flows
Formula field data types
G
Gartner definitions
Governance team
H
Help text
I
Identity & access management
Identity and access management
approach
areas
authentication vs. authorization
definition
formal method
IAM aspects
identity management
implementation
inputs
observations
outputs
phase checklist
phase c standards
Salesforce platform
scenario
single sign-on (SSO)
Apex
App Launcher
areas
connected app
definition
flows
governance team
identity provider
integrations
Just-in-Time provisioning
MFA
MyDomain
OAuth
OpenID
org-wide configurations
project’s application
Salesforce
SAML
service provider
two-factor authentications
steps
stock system
Identity management
de-provisioning
design
external
formal method
inputs
outputs
project team
steps
syncing
Integration
architecture
business risks
components
data backup
data custody
data warehousing strategies
design
external systems
flow
formal method
inputs
options
outliers
outputs
pattern risks
remote process
Call-in integration
data virtualization
fire and forget
lightning component
request and reply
UI update
risks
salesforce patterns
scenario
security
security compliance
solution tools
steps
security
solution tools
technologies
strategy
technical standards
technology
trade-offs
Internally focused communities
J, K
JavaScript libraries
Just-in-Time (JIT)
L
Large data volumes (LDVs)
Least privilege principle
Lightning component framework
Lightning Web Components (LWC)
Load testing
M
Managed packages
Matching rule
Mobile Device Management (MDM)
Mobile solutions architecture
architectural comparison
challenge
checklist
flexibility
governance team
method
approach
inputs
mobile security
mobile strategy/design
outputs
phases
mobile device
mobile strategy/design
phase H method
resources
salesforce
SDK
security
standards
Model-View-Controller pattern
Multi-factor authentication (MFA)
Multi-tenant architecture
N
Normalization
O
Objects
custom
external
types
Open Web Application Security Project (OWASP)
Organization-wide defaults (OWDs)
P, Q
Page layouts
Partner Community
Permission set
Platform as a Service (PaaS)
Platform team
Profiles
Project Object
R
Record types
Relational database management system (RDBMS)
Resource base
Resource links
global deployments
localization
S, T
Salesforce
Salesforce Developer Experience product (SFDX)
Salesforce integrations
Salesforce mobile app
Salesforce org
Salesforce platform
Salesforce platform governance method
Apex/flex queue
Apex/visualforce solution
approach
custom setting
error/exception handling
inputs
maintainability/reuse
model-view-controller pattern
object-oriented language
order of execution
outputs
OWASP
performance/scalability
phase
scenario
sharing/visibility model
steps
technical standards
test coverage
UI options
Salesforce Platform Governance method (SPGM)
application architecture
approach
basic structure
cycle
data architecture and management
elements definitions
GitHub repository
goal
identity and access management
inputs
key points
method adaption
architecture governance
process management
scoping
outputs
phases
resource base
structure
sharing and visibility
steps
deployment techniques
development lifecycle
uses
Salesforce sandbox
Salesforce sharing model
Scratch orgs
Server-side solutions
Service integrator (SI)
Service-oriented architecture (SOA)
Sharing and visibility
approach
areas
data security
classic field encryption
implementation
declarative sharing
SeeDeclarative sharing
definition
features
formal method
Hanna’s proposal
high-volume users
inputs
layers
longer-term view
outputs
performance
programmatic sharing
class security
features
security risks
Salesforce sharing model
scenario
steps
user personas
user types
Sharing model
Sharing options
Sharing requirement document
Sharing/visibility
checklists
data
data security
declarative
governance function
performance impact
phase D standards
programmatic sharing
Single-letter names
Single Sign-On (SSO)
Social aspect
Software as a Service (SaaS)
Software development
Solution architecture (SA)
Source-driven development methodology
Static resources
U
User interface (UI)
User role
V
Validation rules
Visualforce
W, X, Y, Z
Waterfall-based method
Waterfall deployment
Webhooks
Workflow
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.