High-performing agile teams rest on trust and solid engineering fundamentals. Trust creates psychological safety, which lets team members speak up, share ideas, and admit mistakes without fear. When that open, collaborative atmosphere exists, communication patterns improve, decisions happen faster, and the team can adapt more readily to change. Pair that with strong engineering practices—continuous integration, automated testing, clean architectures, maintainable code, and shared standards—and the technical work stays aligned, quality stays high, and changes can be delivered reliably and safely. The other options don’t fit as well because they either promote silos or reliance on a single leader. Highly specialized team members can hinder cross-functionality, which Agile teams rely on to deliver end-to-end value. A strong project manager fits some environments, but Agile emphasizes collaborative, self-organizing teams rather than relying on a single manager. Frequently shifting developers between teams erodes the shared mental model and trust needed for smooth collaboration, reducing velocity and cohesion.

In governance models, three groups must be represented to balance technology, business goals, and real-world use: information technology, the business units that own the processes and requirements, and the end users who will interact with the system. IT brings feasibility, security, and technical standards; business units ensure alignment with strategy, regulations, and operational needs; end users provide practical input on usability, workflows, and adoption. Together, these perspectives ensure decisions consider technical feasibility, business value, and user impact. Focusing only on IT misses the business goals and user experience. Focusing only on end users misses governance, risk, and strategic direction. Focusing only on business units misses technical governance and frontline feedback.

A local repository is the version-control repository that resides on your own computer, containing the project files plus the version history in the hidden .git directory. This is where you can commit, branch, and inspect history offline, without needing a network connection. It becomes local when you clone a repository or initialize one on your machine. In contrast, a repository hosted on GitHub is a remote repository stored on a server, not on your computer; a temporary cloud workspace isn’t the repository itself; and a remote mirror is another copy hosted elsewhere, not the one you have on your machine. So the statement that describes a local repository is that it is stored on the user’s computer.

Not all metadata is captured by source tracking in the package development model. You must manually track changes to components that aren’t yet supported by source tracking to ensure they’re included in the release and can be reproduced in other environments. Source tracking handles many types automatically, but gaps remain for certain metadata types, so manual tracking fills those gaps. Changes made only via the Setup UI aren’t the whole story, and you can’t assume every metadata change is tracked automatically since some types aren’t supported yet. Manual tracking is required specifically for those unsupported components.

Starting with a Salesforce DX app workflow, the very first step is to set up your DX project. This creates the project skeleton—the folder structure, the sfdx-project.json configuration, and the places where metadata and scratch org definitions will live. Without this workspace in place, there’s no centralized context to organize source, track changes, or manage scratch orgs and packages. Once the project exists, you can authorize the Dev Hub to enable scratch org management, then configure the local project settings (like paths and package directories), and finally create a scratch org to begin development. Each later step relies on having the project scaffold, so skipping the setup would leave you with no coherent workspace to operate in.