Knowledge Base

IT Best Practices

Practical, implementation-ready guidance for cybersecurity, Cisco networking, Active Directory, Oracle, WebSphere, desktop configuration, and enterprise user security — drawn from 30+ years of hands-on experience with Fortune 500 and financial services environments.

These are guidelines, not a substitute for a security assessment.

Every environment is different. Coelho Tech recommends a formal risk assessment before implementing any security controls. Need help applying these practices to your Connecticut business? Contact us for a free consultation.

Cybersecurity Best Practices

A layered security posture — defense in depth — is the foundation of any resilient IT environment. These practices apply whether you run 10 workstations or 10,000.

Patch & Vulnerability Management

  • Establish a monthly patch cycle for OS, firmware, and third-party software.
  • Use a vulnerability scanner (Nessus, Qualys, or Rapid7) to prioritize CVEs by CVSS score.
  • Apply critical patches within 72 hours of vendor release.
  • Maintain a software inventory — you cannot patch what you do not know exists.

Endpoint Protection

  • Deploy EDR (Endpoint Detection & Response) on every managed device — not just legacy AV.
  • Enable application allowlisting on high-risk systems (finance, HR, executive).
  • Enforce full-disk encryption (BitLocker on Windows, FileVault on macOS).
  • Block USB mass storage on workstations unless explicitly approved.

Email & Phishing Defense

  • Configure SPF, DKIM, and DMARC records on every sending domain.
  • Enable anti-phishing and safe-links policies in Microsoft 365 Defender or equivalent.
  • Run quarterly phishing simulations and track click rates by department.
  • Quarantine all executable attachments (.exe, .bat, .ps1, .vbs) at the gateway.

Incident Response Readiness

  • Document and test an Incident Response Plan (IRP) at least annually.
  • Define escalation paths: who gets called at 2 AM, and in what order.
  • Maintain offline backups — ransomware targets network-connected backup stores.
  • Practice tabletop exercises simulating ransomware, data breach, and insider threat.

Cisco & Network Configuration Best Practices

Proper network segmentation and hardened device configurations are the first line of defense against lateral movement and unauthorized access.

Device Hardening

  • Disable unused services: CDP on untrusted interfaces, Telnet (use SSH v2 only), HTTP server unless required.
  • Set strong enable secret passwords using type 9 (scrypt) hashing — never type 7.
  • Configure login banners (MOTD) with legal warning language.
  • Enable AAA (Authentication, Authorization, Accounting) with TACACS+ or RADIUS for all device access.

VLAN & Segmentation

  • Segment networks by function: servers, workstations, VoIP, IoT, and guest on separate VLANs.
  • Never use VLAN 1 as a native or management VLAN — reassign to a dedicated VLAN.
  • Apply inter-VLAN ACLs to enforce least-privilege traffic flows.
  • Enable DHCP snooping, Dynamic ARP Inspection (DAI), and IP Source Guard on access ports.

Switching Best Practices

  • Enable PortFast and BPDU Guard on all access ports to prevent STP manipulation.
  • Disable DTP (Dynamic Trunking Protocol) on access ports: switchport nonegotiate.
  • Prune unused VLANs from trunk links.
  • Enable storm control on access ports to limit broadcast/multicast/unicast flooding.

Firewall & Perimeter

  • Default-deny inbound; explicitly permit only required services.
  • Log all denied traffic and review weekly.
  • Implement IPS/IDS in inline mode on internet-facing segments.
  • Use Cisco ASA or Firepower with application-aware policies — not just port/protocol rules.

Desktop Configuration Best Practices

Consistent, policy-driven desktop builds reduce support overhead, close security gaps, and ensure a predictable user experience across the organization.

Baseline Image & Deployment

  • Maintain a hardened golden image per OS version — rebuild quarterly or after major updates.
  • Deploy via MDM (Microsoft Intune, JAMF) or WDS/MDT for Windows environments.
  • Remove bloatware and disable unnecessary Windows features (Cortana, telemetry, remote registry).
  • Apply CIS Benchmark Level 1 settings as a baseline GPO.

User Account Controls

  • Standard users should never have local administrator rights — use LAPS for managed local admin.
  • Enforce screen lock after 5 minutes of inactivity.
  • Disable AutoRun/AutoPlay for all removable media.
  • Restrict PowerShell execution policy to RemoteSigned or AllSigned.

Software & Updates

  • Use WSUS or Intune to centrally manage and approve Windows Updates.
  • Deploy a software deployment tool (SCCM, PDQ Deploy, Intune) — no manual installs.
  • Maintain an approved software catalog; block unapproved installs via AppLocker or WDAC.
  • Uninstall end-of-life software immediately — Java 8, Flash, IE, Office 2016 and older.

Remote Work & VPN

  • Require VPN for all access to internal resources — split-tunnel only for approved traffic.
  • Enforce MFA on VPN authentication (Cisco AnyConnect + Duo or Azure MFA).
  • Apply the same endpoint compliance checks to remote devices as on-premises.
  • Log VPN session data and alert on off-hours or geo-anomalous logins.

Active Directory & User Security Best Practices

Active Directory is the most targeted system in enterprise environments. A compromised AD means a compromised organization — treat it accordingly.

Tiered Administration Model

  • Implement Microsoft's three-tier admin model: Tier 0 (Domain Controllers), Tier 1 (Servers), Tier 2 (Workstations).
  • Never log into Tier 0 systems with accounts used for email or browsing.
  • Use Privileged Access Workstations (PAWs) for all Tier 0 and Tier 1 administration.
  • Restrict Domain Admin membership to 3–5 named accounts maximum.

Account & Password Policies

  • Enforce a minimum 14-character password with complexity — or better, 20+ character passphrases.
  • Enable Fine-Grained Password Policies for privileged accounts (stricter requirements).
  • Audit and disable stale accounts after 30 days of inactivity.
  • Implement Microsoft LAPS for all local administrator accounts on domain-joined machines.

Group Policy Hardening

  • Block credential caching on servers and privileged workstations (Interactive Logon: Number of previous logons to cache = 0).
  • Enable Protected Users security group for all privileged accounts.
  • Restrict NTLM authentication — audit first, then block where possible.
  • Enable audit policies: logon events, account management, privilege use, object access.

Monitoring & Detection

  • Forward all DC Security event logs to a SIEM — at minimum Event IDs 4624, 4625, 4648, 4672, 4768, 4769.
  • Alert on Kerberoasting indicators: unusual TGS requests for service accounts.
  • Run BloodHound/SharpHound quarterly to identify attack paths to Domain Admin.
  • Enable Microsoft Defender for Identity (formerly ATA) for behavioral analytics.

Oracle Database Security Best Practices

Oracle databases frequently house the most sensitive data in the enterprise. Misconfigurations and excessive privileges are the leading causes of Oracle-related breaches.

Installation & Configuration

  • Install Oracle on a dedicated server — never co-locate with application servers or web tiers.
  • Remove or lock default accounts: SCOTT, HR, OE, SH, OUTLN, DBSNMP (or change default passwords immediately).
  • Disable the Oracle listener from accepting remote administration commands (set ADMIN_RESTRICTIONS_LISTENER=ON).
  • Apply the latest Oracle Critical Patch Update (CPU) — Oracle releases quarterly.

Privilege & Access Control

  • Follow least privilege: grant only the specific system and object privileges required.
  • Avoid granting DBA role to application accounts — create custom roles instead.
  • Use Oracle Database Vault to restrict privileged user access to sensitive schemas.
  • Audit all use of SYSDBA and SYSOPER connections.

Auditing & Monitoring

  • Enable Unified Auditing (Oracle 12c+) for DDL, DML on sensitive tables, and privilege use.
  • Use Oracle Audit Vault and Database Firewall (AVDF) for centralized audit management.
  • Alert on after-hours access, bulk SELECT on sensitive tables, and schema changes.
  • Retain audit logs for a minimum of 12 months (24 months for regulated industries).

Encryption & Data Protection

  • Enable Transparent Data Encryption (TDE) for tablespaces containing PII or financial data.
  • Encrypt Oracle Net (SQL*Net) connections using native encryption or SSL/TLS.
  • Use Oracle Data Masking for non-production environments — never copy production data to dev/test unmasked.
  • Store Oracle Wallet files outside the database directory with restricted OS permissions.

IBM WebSphere Application Server (WAS) Best Practices

WebSphere environments in financial services and enterprise settings require careful hardening — default configurations expose unnecessary attack surface.

Installation & Hardening

  • Run WAS under a dedicated, non-root service account with minimal OS privileges.
  • Disable the administrative console on production nodes — manage via Deployment Manager only.
  • Remove sample applications (snoop, hitcount, DefaultApplication) from all production servers.
  • Apply IBM Fix Packs and Interim Fixes on a quarterly cycle — subscribe to IBM Security Bulletins.

SSL/TLS Configuration

  • Disable SSLv3, TLS 1.0, and TLS 1.1 — enforce TLS 1.2 minimum, prefer TLS 1.3.
  • Use strong cipher suites: AES-256-GCM, ECDHE for key exchange — disable RC4, DES, 3DES.
  • Manage certificates via the WAS keystore — set expiry alerts at 60 and 30 days.
  • Enable HSTS headers on all HTTPS endpoints.

Application Security

  • Enable Java 2 Security to enforce permission-based access control for deployed applications.
  • Configure application-level security roles — do not rely solely on network-level controls.
  • Enable CSRFGuard or equivalent for all web applications.
  • Restrict HTTP methods: disable TRACE and OPTIONS at the web container level.

Logging & Monitoring

  • Enable WAS security auditing: authentication, authorization, and admin actions.
  • Forward SystemOut.log and SystemErr.log to a centralized SIEM.
  • Set JVM heap alerts — memory exhaustion is a common availability attack vector.
  • Monitor thread pool utilization and set alerts at 80% saturation.

User Security & Access Management Best Practices

People remain the most targeted attack vector. Technical controls must be paired with clear policies, training, and frictionless secure workflows.

Multi-Factor Authentication

  • Require MFA for all remote access, cloud applications, email, and privileged accounts — no exceptions.
  • Prefer authenticator apps (Microsoft Authenticator, Duo) or hardware keys (YubiKey) over SMS.
  • Implement Conditional Access policies: block legacy authentication protocols (SMTP AUTH, IMAP, POP3).
  • Enroll MFA at onboarding — do not allow a grace period.

Identity Lifecycle Management

  • Automate provisioning and deprovisioning via HR system integration (Workday, BambooHR to Azure AD).
  • Revoke all access within 1 hour of termination — include VPN, email, SaaS, and physical badges.
  • Conduct quarterly access reviews: managers certify their team access to applications.
  • Implement Just-In-Time (JIT) access for privileged roles — no standing admin rights.

Security Awareness Training

  • Deliver role-based training annually — finance, HR, and IT staff need targeted modules.
  • Run monthly phishing simulations; provide immediate coaching for users who click.
  • Train on social engineering: vishing, pretexting, and physical tailgating.
  • Establish a clear report-suspicious-email process — make it one click.

Data Handling & DLP

  • Classify data at creation: Public, Internal, Confidential, Restricted.
  • Deploy Data Loss Prevention (DLP) policies in Microsoft Purview or equivalent.
  • Block upload of Confidential/Restricted data to personal cloud storage (Google Drive, Dropbox).
  • Encrypt all email containing PII, financial data, or health information.

General Server Hardening Best Practices

Whether on-premises or cloud-hosted, servers require a consistent hardening baseline applied at provisioning and maintained through the lifecycle.

OS Hardening

  • Apply CIS Benchmarks (Level 1 minimum) for Windows Server and Linux distributions.
  • Disable unnecessary services and remove unused roles/features.
  • Enable host-based firewall (Windows Firewall, iptables/nftables) with default-deny inbound.
  • Configure NTP synchronization to an authoritative time source — critical for log correlation.

Access & Authentication

  • Disable root SSH login — use sudo with individual named accounts and key-based authentication.
  • Restrict SSH to management VLANs via firewall rules and AllowUsers/AllowGroups in sshd_config.
  • Rotate service account passwords annually and after any personnel change.
  • Enable login failure lockout: 5 failed attempts triggers a 15-minute lockout.

Backup & Recovery

  • Follow the 3-2-1 rule: 3 copies, 2 different media types, 1 offsite.
  • Test restores quarterly — a backup you have never restored is not a backup.
  • Encrypt backup data at rest and in transit.
  • Store at least one backup copy air-gapped or immutable (object lock, WORM).

Change Management

  • All production changes require a change ticket with rollback plan.
  • Maintain configuration baselines in version control (Ansible, Puppet, or Git-backed scripts).
  • Use infrastructure-as-code for cloud resources — no manual console changes in production.
  • Conduct post-implementation reviews for all major changes within 48 hours.

AI Implementation Best Practices

Enterprise AI delivers real value only when it is introduced deliberately — narrow scope first, proven workflow before authority, and instrumented end-to-end. These practices reflect hard-won lessons from production AI deployments in IT operations, asset management, and financial services.

Start Narrow — One Flow at a Time

  • Pick one well-defined, repetitive task for your first pilot: asset inventory queries, ticket triage, or patch-status summaries.
  • Resist the urge to automate everything at once — a focused pilot produces measurable ROI and builds organizational trust.
  • Simple starting questions work well: What equipment do we have? Who owns it? What is underused? What needs replacement?
  • Pull answers from inventory, purchasing, and monitoring systems — structured data sources the model can reason over reliably.

Prove the Workflow Before Granting Authority

  • Run the agent in read-only / suggest mode first — it recommends actions, a human approves them.
  • Only promote to autonomous execution after the suggestion accuracy rate meets your defined threshold (e.g., 95% over 30 days).
  • Document the approval chain: who can authorize an agent to act, and on what class of tasks.
  • Treat each new capability as a new pilot — authority earned in one domain does not transfer automatically.

Give Agents Limited Authority

  • Scope API permissions to the minimum required: read-only where possible, write-scoped to specific resource types.
  • Use separate service accounts per agent — never share credentials across workflows.
  • Set hard rate limits and budget caps on agent-initiated API calls to prevent runaway automation.
  • Log every action the agent takes with a timestamp, input, output, and the identity of any approving human.

Treat Retrieved Content as Untrusted

  • Data fetched from external sources, user inputs, and even internal databases can contain prompt-injection payloads.
  • Sanitize and validate all retrieved content before passing it to the model context.
  • Never allow retrieved content to override system-level instructions or expand agent permissions.
  • Use a separate validation layer to check agent outputs before they trigger downstream actions.

Build an Evaluation Set Early

  • Before deploying, assemble 50–100 representative examples with known correct outputs — your ground truth.
  • Run the eval set on every model or prompt change; regressions block deployment.
  • Include adversarial cases: ambiguous inputs, missing data, and edge conditions the agent will encounter in production.
  • Track accuracy, latency, and cost per completed task over time — not just whether the agent "works."

Instrument the Entire Workflow

  • Log inputs, retrieved context, model outputs, tool calls, and final actions — every step, not just the result.
  • Emit structured traces (OpenTelemetry or equivalent) so you can replay and debug any failure.
  • Alert on anomalies: unusually long chains, repeated tool failures, or outputs that fall outside expected value ranges.
  • Review a random sample of completed tasks weekly — automated metrics miss subtle quality drift.

Design Guardrails at Every Layer

  • System prompt: define the agent role, scope, and explicit refusal rules (what it must never do).
  • Input guardrails: validate and sanitize user and retrieved inputs before they reach the model.
  • Output guardrails: check model responses against a schema or classifier before acting on them.
  • Fallback path: every agent workflow must have a graceful human-handoff when confidence is low or an action fails.

Optimize Cost Per Completed Task

  • Use the smallest model that meets your accuracy bar — GPT-4o-mini or Claude Haiku for triage, larger models only for complex reasoning.
  • Cache deterministic lookups (asset records, policy documents) rather than re-fetching on every turn.
  • Trim context aggressively: pass only the data the model needs for the current step, not the full conversation history.
  • Set a cost budget per workflow and alert when a task exceeds it — runaway token usage is a real production risk.

Release Gradually

  • Shadow mode first: run the agent in parallel with the existing process, compare outputs, fix gaps.
  • Canary release to 5–10% of traffic or a single team before broad rollout.
  • Define rollback criteria in advance — if accuracy drops below threshold or an incident occurs, revert immediately.
  • Communicate clearly to end users what the agent can and cannot do; set expectations before they interact with it.

Useful IT Operations Pilots

  • Asset & capacity analyst: query inventory, purchasing, and monitoring data to answer "what do we have, who owns it, what is underused, and what needs replacement" — no human data-wrangling required.
  • Ticket triage agent: classify incoming support tickets by category, priority, and likely owner; suggest KB articles before routing to a technician.
  • Patch status summarizer: pull vulnerability scanner and WSUS/Intune data, surface overdue patches by severity and asset owner.
  • Vendor contract monitor: ingest contract dates and alert on renewals, SLA breaches, and spend anomalies 90/60/30 days out.

Building AI Employee Agents: Best Practices

AI employee agents are purpose-built software workers that operate inside your existing tools, handle defined tasks autonomously, and hand off to humans when judgment is required. Done right, they extend your team without adding headcount. Done wrong, they create liability. These practices reflect what separates production-grade agents from demos.

Define the Job Description Before You Build

  • Write a one-page "agent job description" before touching code: inputs, outputs, decision authority, escalation triggers, and success metrics.
  • Agents with vague scope drift — they attempt tasks outside their competence and produce confident-sounding wrong answers.
  • Identify the single workflow the agent owns end-to-end; resist combining multiple unrelated jobs into one agent.
  • Define what the agent must never do as explicitly as what it should do — refusal rules are as important as capability rules.

Ground Every Agent in Your Own Data

  • Connect agents to your authoritative data sources — CRM, ticketing system, knowledge base, ERP — not to general internet knowledge.
  • Use retrieval-augmented generation (RAG) to pull relevant records at query time rather than baking stale data into the model.
  • Chunk and index documents with metadata (source, date, owner) so the agent can cite its sources and you can audit its reasoning.
  • Refresh your vector index on a schedule that matches how often the underlying data changes — stale retrieval is a silent failure mode.

Design the Human Handoff First

  • Every agent workflow must have a clearly defined handoff condition: low confidence score, missing required data, or action outside approved scope.
  • Route escalations to a named human or queue — "contact support" is not a handoff, it is an abandonment.
  • Preserve full context on handoff: conversation history, retrieved documents, and the reason for escalation so the human does not start from scratch.
  • Track handoff rate as a primary KPI — a rising rate signals the agent is encountering cases it was not designed for.

Scope Permissions to the Minimum Viable Access

  • Create a dedicated service account per agent with only the API scopes and database roles it needs for its defined job.
  • Never share credentials between agents — isolation limits blast radius when something goes wrong.
  • Use read-only access by default; promote to write access only after the read-only pilot meets your accuracy threshold.
  • Audit agent permissions quarterly the same way you audit human user accounts — revoke anything unused.

Build Observability In from Day One

  • Log every agent action: timestamp, input, retrieved context, model output, tool calls made, and final action taken.
  • Emit structured traces (OpenTelemetry or equivalent) so you can replay any interaction and debug failures deterministically.
  • Set alerts on anomalies: unusually long reasoning chains, repeated tool failures, outputs outside expected value ranges, or cost spikes.
  • Review a random 5% sample of completed tasks weekly — automated metrics miss subtle quality drift that accumulates over time.

Test Against Adversarial Inputs Before Launch

  • Build a golden dataset of 50–100 representative tasks with known correct outputs before deploying to production.
  • Include adversarial cases: ambiguous requests, missing required fields, conflicting data, and prompt-injection attempts in retrieved content.
  • Run the full eval set on every prompt or model change — regressions block deployment, not just failures.
  • Simulate the handoff path: verify the agent escalates correctly when it should, not just that it answers correctly when it can.

Document and Hand Off Like a Real Employee

  • Produce a runbook for every deployed agent: what it does, what data it accesses, how to monitor it, and how to disable it.
  • Version-control your system prompts alongside your application code — treat a prompt change as a code change.
  • Train the humans who work alongside the agent: what it can and cannot do, how to interpret its outputs, and when to override it.
  • Schedule a 30-day post-launch review: measure actual vs. projected task volume, accuracy, cost, and handoff rate, then tune.

Plan for Model and Vendor Changes

  • Abstract your model calls behind a thin interface layer so you can swap providers without rewriting business logic.
  • Evaluate new model versions against your golden dataset before promoting them to production — "better on benchmarks" does not mean better on your tasks.
  • Monitor for model behavior drift: providers update models silently; a task that worked last month may behave differently today.
  • Maintain a rollback path: keep the previous prompt version and model pinned so you can revert within minutes if a deployment degrades.

Ready to implement these practices?

Coelho Tech helps Connecticut businesses apply enterprise-grade security and IT standards — without the enterprise overhead.