<h1>Technology Stocks and Christian Screening</h1>

<p>Technology stocks represent nearly one-third of the S&P 500 index and dominate most diversified investment portfolios. For Christian investors seeking to align their investments with biblical values, technology companies present a unique paradox: they are nearly impossible to avoid without significantly sacrificing diversification, yet many have ethically complex profiles that raise serious concerns. This article explores how Christian investors should think about technology stocks, the specific challenges these companies present, and practical frameworks for evaluating them through a faith-based lens.</p>

<h2>Why Technology Companies Present Unique Challenges for Christian Investors</h2>

<p>Technology has become the backbone of modern society. From communication to healthcare to education, tech companies facilitate essential services that serve legitimate human needs. Apple, Microsoft, Google, and Amazon are not peripheral to the economy—they are central to it. This creates a genuine dilemma for Christian investors.</p>

<p>Unlike tobacco, gambling, or alcohol companies—where the primary business model involves selling products that many Christians believe violate biblical principles—technology companies' primary business often appears benign. Microsoft sells productivity software. Apple sells computers and phones. But the ethical questions arise not from their primary products but from how those companies operate, what they profit from, what policies they enforce, and what values they embody in their corporate decisions.</p>

<p>A technology company can profit from both beneficial and harmful activities simultaneously. Google's search engine and email services are genuinely useful to billions of people. Yet Google also serves advertisements on pornographic websites, hosts pirated content, and has struggled with oversight of its advertising networks. Amazon provides rapid delivery and convenient shopping, but its warehouse workers report grueling conditions and constant surveillance. These contradictions mean that simply excluding all technology stocks isn't realistic, but neither is ignoring their ethical profile.</p>

<p>The dominance of technology in market indexes also means that excluding the entire sector significantly impacts portfolio performance and diversification—a concern that creates real tension between Christian principles and financial prudence.</p>

<h2>Content Moderation and Free Speech: The Social Media Dilemma</h2>

<p>Social media platforms—primarily Meta (Facebook and Instagram), Alphabet (Google and YouTube), and X (Twitter)—face intense scrutiny regarding what content they allow, how they moderate it, and what they profit from. For Christian investors, this presents several interconnected ethical questions.</p>

<h3>Pornography and Adult Content</h3>

<p>Meta and Google's advertising networks have generated significant revenues from platforms hosting adult content. Research has shown that Google search ads appear on pornography websites, and Meta's advertising platforms have been documented serving ads in compromising placements. While the companies argue they are not directly producing this content, their advertising and payment processing systems enable the pornography industry to function profitably.</p>

<p>A 2018 investigation found that apps hosting links to child exploitation material actually received financial support through Google AdMob and Facebook's Audience Network, showing how advertising networks can inadvertently (or negligently) fund illegal content creation. More recently, Meta has faced criticism for allowing advertisements for AI-powered "nudify" apps—which create non-consensual explicit images—on Facebook and Instagram despite clear policy violations.</p>

<p>For Christians who believe that viewing pornography distorts God's design for sexuality and harms both consumers and those exploited in its production, owning stock in companies that profit from the pornography industry creates a direct moral conflict.</p>

<h3>Hate Speech and Religious Expression</h3>

<p>Social media platforms also grapple with how to handle hate speech, misinformation, and extremism. These are genuinely difficult moderation questions with no perfect answers. However, Christian investors should understand that content moderation policies inherently reflect values and priorities. Some policies may suppress religious expression or discriminate against conservative Christian viewpoints. Other policies may insufficiently address genuine harms.</p>

<p>These platforms' moderation systems are not neutral—they embed choices about what speech is acceptable, who gets to decide, and what constitutes harm. For Christian investors, understanding a company's content policies and whether they align with Christian values of truth, justice, and religious freedom is an important part of stewardship.</p>

<h2>Privacy and Surveillance: Data Harvesting and the Panopticon Problem</h2>

<p>Technology companies collect vast amounts of personal data from their users. This data fuels targeted advertising, algorithmic recommendations, and—increasingly—government surveillance programs. For Christians concerned with stewardship and protecting human dignity and privacy, this raises serious questions.</p>

<h3>Biometric Data and Facial Recognition</h3>

<p>Facial recognition technology, often developed and deployed by major tech companies, enables identification of individuals without their knowledge or consent. Companies like Google, Amazon (through subsidiaries), and Microsoft have developed facial recognition systems used by law enforcement and private security. While legitimate uses exist, the technology also enables mass surveillance and can be deployed oppressively.</p>

<p>Beyond facial recognition, companies harvest biometric data—fingerprints, facial features, voice patterns—often without informed consent. Clearview AI famously scraped billions of images from social media to build a facial recognition database used by private companies and law enforcement. Even as users are unaware of it, their biometric data is being collected, stored, and analyzed by tech companies for commercial and governmental purposes.</p>

<h3>Government Surveillance Programs</h3>

<p>Technology companies serve as infrastructure for government surveillance. Tech companies provide cloud services, data storage, and processing power to government agencies. While some legitimate government functions require technology, the scale and scope of modern surveillance raise concerns. The NSA's bulk data collection programs relied heavily on infrastructure provided by private tech companies. Government requests for user data from tech companies number in the millions annually.</p>

<p>For Christians who value privacy as a reflection of human dignity and believe that humans should not be subject to constant monitoring (except by God), enabling government surveillance is a legitimate ethical concern.</p>

<h2>Artificial Intelligence Ethics: Bias, Displacement, and Autonomous Weapons</h2>

<p>Artificial intelligence represents the next frontier in computing, and technology companies are racing to develop and deploy AI systems across every domain of human activity. This creates several ethical concerns that Christian investors should understand.</p>

<h3>Algorithmic Bias and Discrimination</h3>

<p>AI systems are trained on historical data. When that data reflects historical biases—racial discrimination, gender discrimination, socioeconomic disparities—the AI system learns and perpetuates those biases at scale. Facial recognition systems misidentify people of color at higher rates. Hiring algorithms can discriminate based on protected characteristics. Loan approval algorithms can perpetuate discriminatory lending practices.</p>

<p>For Christians committed to justice and equal treatment, funding companies that deploy biased AI systems that harm vulnerable populations is problematic. The problem is not hypothetical—these failures have already occurred in real-world deployment.</p>

<h3>Job Displacement and Economic Disruption</h3>

<p>AI-driven automation is expected to significantly reshape labor markets. Projections suggest that 15-25% of jobs will face significant disruption by 2025-2027, with lasting net job displacement after new roles are created. While technological progress has always created some job displacement, the scale and speed of AI-driven automation raises genuine concerns.</p>

<p>Christians called to care for the poor and vulnerable should consider whether supporting companies that profit from displacement of workers is consistent with biblical values. This doesn't necessarily mean excluding all tech stocks, but it means understanding the labor impact of companies' AI strategies.</p>

<h3>Deepfakes and Misinformation</h3>

<p>AI technology enables creation of synthetic media—deepfake videos, AI-generated images, fabricated text—that can spread false narratives at scale. The technology companies building these systems face a choice about how to deploy them. Some attempt to build safeguards; others enable creation of non-consensual explicit deepfakes used for harassment and extortion.</p>

<p>For Christians committed to truth, watching tech companies deploy AI technology that enables deception and the creation of non-consensual explicit imagery is concerning.</p>

<h3>Autonomous Weapons</h3>

<p>Technology companies are developing AI systems for military applications. An autonomous weapon system could make life-and-death targeting decisions without direct human authorization. For Christians who believe in the sanctity of human life and believe that life-and-death decisions require human moral agency, autonomous weapons powered by AI raise profound ethical concerns.</p>

<h2>Military Contracts and Defense Applications: Project Maven and Beyond</h2>

<p>Several major technology companies have contracts with the U.S. Department of Defense to develop artificial intelligence and other technologies for military applications. These contracts raise ethical questions for Christian investors about complicity in warfare and the weaponization of civilian technology.</p>

<h3>Project Maven</h3>

<p>Project Maven, launched by the Department of Defense in 2017, uses AI to analyze drone surveillance video to identify and track objects. The program was initially assigned to Google, which led thousands of Google employees to protest. Their letter stated: "We believe that Google should not be in the business of war." Google did not renew its Project Maven contract in 2019, citing concerns about alignment with its stated AI principles.</p>

<p>However, Project Maven continued. Amazon and Microsoft have since become major Department of Defense contractors for AI and cloud infrastructure projects. The JEDI (Joint Enterprise Defense Infrastructure) contract—worth billions and spanning a decade—involves cloud infrastructure that supports military operations, including surveillance and targeting functions.</p>

<h3>Assessing Military Contracts</h3>

<p>For Christian investors, the question is whether profit from military contracts, particularly those involving AI targeting and surveillance, is consistent with Christian values. Some Christians maintain that military defense is a legitimate government function and that working with the government on defense is acceptable. Others argue that the development of autonomous weapons and mass surveillance tools goes beyond legitimate defense and raises serious moral concerns.</p>

<p>Most Christian funds hold companies with military contracts. This reflects a pragmatic decision that excluding all companies with Department of Defense contracts would eliminate much of the technology sector and severely impact diversification. But this is a decision Christian investors should make consciously, understanding the tradeoffs.</p>

<h2>Pornography Distribution: Tech Industry's Uncomfortable Role</h2>

<p>Beyond advertising networks, technology companies play direct roles in the pornography industry through payment processing, content hosting, and infrastructure provision. This is an area where Christian investing frameworks have been particularly clear.</p>

<p>Payment processors like Stripe, Square, and others handle transactions for adult content platforms. Web hosting companies provide infrastructure. Advertising networks serve ads on pornography sites. While each company involved might argue they are simply providing neutral infrastructure, the effect is enabling the entire industry to function profitably.</p>

<p>For Christians who believe that pornography exploitation harms both consumers and those exploited in its production, and that Christian stewardship means not profiting from industries built on sexual exploitation, companies that enable pornography distribution are problematic investments.</p>

<p>The challenge is that some technology companies are less directly involved than others. A payment processor that directly processes adult industry transactions is more complicit than a general-purpose web hosting company that happens to host some adult content. Christian screening frameworks typically take a tiered approach, with stricter exclusion of companies whose business models directly depend on adult content versus those with more tangential involvement.</p>

<h2>The Gig Economy and Labor Practices: Amazon as Case Study</h2>

<p>Amazon and similar gig economy companies have created business models that depend on a large workforce classified as independent contractors, not employees. This classification allows companies to minimize labor costs, avoid providing benefits, and transfer business risks onto workers.</p>

<h3>Warehouse and Delivery Worker Conditions</h3>

<p>Amazon warehouse workers report intense pace and pressure, with electronic monitoring of productivity at individual level. Workers describe grueling physical demands and insufficient breaks. The U.S. Department of Labor has cited Amazon for exposing workers to hazardous conditions. Workers in counties with Amazon warehouses earn significantly less than workers in comparable counties without Amazon warehouses, suggesting that Amazon's large presence actually depresses local wages.</p>

<p>Amazon's surveillance of employees goes beyond normal workplace monitoring. The company has been documented monitoring employee activism to prevent unionization efforts. This level of surveillance combined with high-pressure work conditions raises serious questions about dignity and respect for workers.</p>

<h3>Independent Contractor Misclassification</h3>

<p>Amazon Flex drivers and similar gig workers are classified as independent contractors, which means they lack fundamental protections: minimum wage guarantees, overtime pay, paid leave, guaranteed work schedules, health insurance, workers' compensation, and workplace protections against discrimination and harassment.</p>

<p>For Christians who believe in the dignity of work and workers' right to fair treatment, supporting companies that deliberately misclassify workers to avoid providing basic protections is ethically problematic.</p>

<p>Most mainstream Christian funds do hold Amazon stock, reflecting the view that Amazon's overall business is legitimate and that labor concerns, while real, don't warrant complete exclusion. But this is a conscious decision about accepting imperfection for diversification benefits.</p>

<h2>Video Game Companies and Violent and Sexual Content</h2>

<p>Major technology and entertainment companies (including Sony, Microsoft through Xbox, Nintendo, and others) profit from video game publishing and platform operation. Some video games contain graphic violence, sexual content, or both. This raises questions for Christian investors about complicity in distribution of content they find ethically problematic.</p>

<h3>Content and Consistency</h3>

<p>Sony has policies restricting sexual content in games—largely enacted after #MeToo concerns. However, these policies apply inconsistently. Games developed by Sony-owned studios (like The Last of Us Part II) contain graphic violence and sexual content comparable to or exceeding independently-developed games that Sony has required to be censored. This inconsistency raises questions about whether policies reflect genuine ethical commitments or corporate protection.</p>

<p>Nintendo claims it doesn't regulate content beyond requiring regional age ratings, allowing sexually explicit games on its platform if they receive appropriate ratings.</p>

<p>For Christian investors, the question is whether profiting from publishing and distributing games with graphic violent and sexual content conflicts with Christian values. This is complicated by the reality that video games are an enormous market (exceeding 100 billion dollars globally) and major tech companies' involvement in gaming is a significant part of their business.</p>

<h2>How Christian Fund Families Approach Technology Screening</h2>

<p>Several Christian fund families have developed systematic approaches to evaluating technology companies. Understanding these frameworks is helpful for individual Christian investors developing their own evaluation methods.</p>

<h3>Inspire Investing's Impact Score System</h3>

<p>Inspire Investing uses a numerical Inspire Impact Score ranging from -100 to 100 to rate companies based on alignment with biblical values. The system uses both positive screens (identifying companies that operate as blessings to customers, communities, workforce, and the world) and negative screens (excluding companies involved in abortion, pornography, human rights violations, environmental destruction, and other areas deemed contrary to biblical values).</p>

<p>According to Inspire's methodology, 92% of the approximately 30,000 companies they screen pass all biblical screening criteria. This suggests that their screens are not as restrictive as some might assume. However, the specific Inspire Impact Scores for major technology companies reveal how they weigh various ethical concerns.</p>

<p>The Inspire approach attempts to be comprehensive, weighing many ethical factors simultaneously. This allows for a more nuanced evaluation than simple inclusion/exclusion criteria. A company with concerning labor practices might still receive a moderate score if it scores well on other dimensions like environmental stewardship or community impact.</p>

<h3>Timothy Plan's Approach</h3>

<p>The Timothy Plan uses a screening system specifically designed to exclude companies involved in activities contrary to biblical principles. Notably, Timothy Plan explicitly screens out companies involved (directly or indirectly) in pornography or promotion of adult themes through media, games, stores, online platforms, and other channels.</p>

<p>The Timothy Plan also screens out companies promoting anti-family entertainment or alternative lifestyles, as well as companies involved in abortion, embryonic stem cell research, and other areas deemed contrary to biblical teaching.</p>

<p>This approach is more explicitly values-based than Inspire's, with less room for balancing competing concerns. A company involved in pornography distribution would likely be excluded entirely rather than receiving a partial score.</p>

<h3>Why Most Christian Funds Hold Major Tech Stocks</h3>

<p>Despite concerns about specific ethical issues, most Christian-oriented mutual funds hold major technology stocks like Apple, Microsoft, Google, and Amazon. This reflects several considerations:</p>

<ul>
<li><strong>Diversification Requirements:</strong> Excluding the entire technology sector would create a portfolio insufficiently diversified to manage risk. Technology represents 25-30% of the S&P 500; completely avoiding it would be impractical for most investors.</li>

<li><strong>Degree of Concern:</strong> Most Christian screening frameworks recognize that companies can have both ethical strengths and ethical weaknesses. Apple, for instance, has strong labor and environmental practices but may distribute content concerning to Christians. The overall evaluation depends on how different ethical dimensions are weighted.</li>

<li><strong>Distinction Between Primary and Incidental Activities:</strong> Apple's primary business is designing and selling technology products. Apple does not profit primarily from pornography or weapons development, even though incidental activities related to these industries occur on Apple platforms. This distinction matters in screening frameworks.</li>

<li><strong>Realistic Imperfection:</strong> Christian fund managers recognize that in a fallen world, virtually no company will be ethically perfect. The question is not whether a company is perfect but whether its overall business model and practices align reasonably well with Christian values. Most decide that some major tech companies meet this threshold, even if imperfectly.</li>
</ul>

<h2>The Benefits of Technology: Why Complete Avoidance Is Problematic</h2>

<p>Any comprehensive discussion of Christian investing and technology must acknowledge that technology companies also provide genuine benefits that Christians value and depend on.</p>

<p>Medical technology companies develop diagnostic tools, treatment therapies, and devices that save lives and reduce suffering. Educational technology enables access to learning resources globally. Communication platforms connect family members separated by geography. Cloud computing enables nonprofits and churches to operate efficiently.</p>

<p>Technology companies also employ millions of people globally, provide retirement income through stock ownership, and drive innovation that improves human welfare in numerous ways.</p>

<p>Complete avoidance of technology would mean refusing these benefits, which is neither realistic nor necessarily wise stewardship. Stewardship sometimes means accepting imperfection and engaging with complex ethical situations rather than attempting purity through complete withdrawal.</p>

<h2>Practical Framework for Evaluating Technology Stocks as a Christian Investor</h2>

<p>Given the complexity, here is a practical framework Christian investors can use to evaluate specific technology companies:</p>

<h3>Step 1: Identify Revenue Sources</h3>

<p>Where does the company make money? What percentage of revenue comes from different business segments? A company that derives 5% of revenue from adult content platforms has a different ethical profile than one deriving 50% from the same source. Understanding revenue sources clarifies how implicated a company is in various activities.</p>

<h3>Step 2: Evaluate Content Policies</h3>

<p>For technology platforms with content moderation responsibility, what are the company's actual policies regarding pornography, hate speech, violent content, and other concerns? Are policies applied consistently? Are there gaps or loopholes? The quality and consistency of content moderation reflects corporate values.</p>

<h3>Step 3: Examine Labor Practices</h3>

<p>How does the company treat its workforce? What wages does it pay? What benefits does it provide? Does it respect workers' right to organize? Are working conditions safe and respectful? Labor practices reveal whether a company genuinely respects human dignity or merely exploits it for profit.</p>

<h3>Step 4: Assess Privacy and Surveillance</h3>

<p>What data does the company collect? How is it used? Is informed consent obtained? Does the company push back against government surveillance requests or cooperate extensively? Privacy practices reflect whether the company respects human autonomy and dignity.</p>

<h3>Step 5: Consider Military and Government Contracts</h3>

<p>Does the company have military contracts? If so, what are they for? Are they for general infrastructure or specifically for weaponization and targeting? How the company engages with government reflects its willingness to contribute to different types of governmental activity.</p>

<h3>Step 6: Evaluate AI Ethics Practices</h3>

<p>If the company develops artificial intelligence, what safeguards does it have against bias, misuse, and harmful deployment? Does the company engage in meaningful ethics review of AI applications? Corporate commitment to AI safety reflects forward-thinking ethical responsibility.</p>

<h3>Step 7: Make a Weighted Decision</h3>

<p>Few technology companies will score perfectly on all dimensions. The question is whether the overall profile—considering both ethical concerns and benefits—aligns reasonably well with Christian values and your personal convictions.</p>

<p>A company might score well on labor practices and environmental stewardship but have concerning content moderation. Another might have excellent privacy protections but problematic military contracts. How you weight these competing concerns is personal to your own ethical framework and convictions.</p>

<h3>Step 8: Consider Alternatives</h3>

<p>For each major technology company, are there alternatives with better ethical profiles? For cloud services, are there Christian-owned providers or companies with stronger privacy commitments? For consumer devices, are there companies with better labor practices? Sometimes alternatives exist that align better with Christian values, even if they involve slightly different capabilities or higher costs.</p>

<h3>Step 9: Accept Imperfection and Document Your Reasoning</h3>

<p>In a fallen world, perfect options rarely exist. Holding technology stocks may involve accepting some level of ethical compromise for diversification and economic benefit. This is acceptable, but you should understand and document what compromise you are making and why. This keeps you accountable to your own stated values.</p>

<h2>The Tension Between Benefits and Risks</h2>

<p>Ultimately, Christian investing in technology stocks involves navigating genuine tension. Technology companies create products and services that benefit billions of people and enable legitimate human activity. Yet many of these same companies also profit from pornography, enable surveillance, develop weapons, exploit workers, and distribute content Christians find morally problematic.</p>

<p>This tension cannot be fully resolved. Complete avoidance of technology is neither realistic nor necessarily wise, as it would sacrifice diversification and deny genuine benefits. But uncritical acceptance of technology stocks as part of an investment portfolio also ignores genuine ethical concerns.</p>

<p>The Christian approach involves neither complete withdrawal nor uncritical acceptance, but rather thoughtful engagement. Understand the ethical profile of companies you own. Make conscious decisions about which concerns matter most to you. Accept imperfection while maintaining accountability to your values. Use your status as a shareholder to advocate for ethical improvement when possible.</p>

<p>Christian investors can hold technology stocks while also holding technology companies accountable and working toward a technology sector that operates with greater integrity, respect for human dignity, and alignment with Christian values. This engagement—taking ethics seriously while navigating real-world complexity—is ultimately the call of faithful stewardship.</p>