- Home
- Articles
- Choosing software
- E-File Magic Security: How We Protect Your Tax Data
FILING WORKFLOW
Security by Design: How E-File Magic Protects Your Tax Data
Protecting tax information takes care at every step. Explore the engineering behind E-File Magic—from account-bound encryption and secure sign-in to recipient access and carefully controlled software releases.
Source review:
Filing guideIn this guide
- Security follows the entire filing workflow
- Protection begins before a request reaches your records
- A foundation built with memory safety in mind
- Encryption protects the data and its context
- Strong sign-in continues into the session
- Account isolation is enforced by the server
- Imported files are treated as untrusted input
- Protecting the integrity of the work
- Recipient access is a protected workflow
- Reducing unnecessary sensitive data
- Connected tools follow explicit access boundaries
- Security includes how software reaches the system
- Accountability and resilience are part of protection
- Evaluate the platform with confidence
- Sources & further reading
A tax form carries information people trust you to protect: names, addresses, taxpayer identification numbers, and financial details. For a business or accounting firm, choosing filing software means choosing a system that will handle that trust through preparation, filing, delivery, and follow-up.
E-File Magic approaches security as an engineering responsibility across that entire workflow. The choices reach from our programming language and encryption model to account permissions, recipient access, background processing, and the way we release software. Each layer has a specific job, and the layers work together.
This article expands on our Technology & Security overview. It explains the architecture at a useful level for customers and technical reviewers, while keeping private operational details private.
Security follows the entire filing workflow
We design around three related responsibilities: keeping information confidential, preserving the accuracy and history of records, and keeping work recoverable when something is interrupted. A filing platform needs all three. A protected record that is changed incorrectly, or a processing task that disappears after a timeout, can still create a serious problem for a customer.
The core application uses Rust services on AWS Lambda, Amazon DynamoDB for durable business records and transactions, Amazon SQS for background work, and AWS Key Management Service, or KMS, to protect encryption keys. Private object storage supports files and documents. The browser presents the workspace; the backend decides which operations a person or integration is allowed to perform.
- At entry: protected connections, sign-in checks, request limits, and server-side validation.
- During storage: application-layer encryption, account-scoped access, and protected lookup information.
- During processing: recorded state, version checks, transactions, and recoverable background work.
- At delivery: a verified access flow, limited document sessions, and recorded download activity.
- As the system changes: reviewed source, artifact verification, vulnerability checks, and controlled deployment.
These boundaries matter because a customer record may pass through several services before a filing is complete. Security needs to remain part of the handoff, not depend on a single check at the beginning.
Protection begins before a request reaches your records
The AWS deployment architecture uses encrypted HTTPS connections with modern TLS policies, managed web application firewall rules, and traffic rate controls. Those protections help screen common malicious requests and limit abusive traffic before it consumes application resources. Application-level limits add checks appropriate to the operation, including authentication and public access flows.
The browser also receives security policies that constrain where content can load from and how pages can be embedded. Protected responses use cache controls intended to prevent sensitive application results from being retained in shared caches. These controls complement the access checks inside the application; a request still has to be authorized after it reaches the service.
For customers, the benefit is a series of checks between an incoming request and a sensitive record. A connection reaching the website does not establish permission to retrieve filing data.
A foundation built with memory safety in mind
E-File Magic's backend is written in Rust. Rust's ownership rules are checked by the compiler and help prevent common memory-management errors, including using memory after it has been released. Choosing a language with these protections reduces an important class of implementation risk at the foundation of the service. [3]
The application also uses typed contracts, explicit validation, and bounded processing. Incoming values are checked on the server, and accepted fields follow the applicable form and tax-year contract. Text is handled through established sanitization rules. File parsers and document operations have size and resource limits.
Language safeguards and validation solve different problems. Rust helps with memory safety; authorization determines access; form validation checks whether submitted information fits the supported contract. Keeping those responsibilities explicit makes the system easier to reason about and review.
Encryption protects the data and its context
HTTPS protects information while it travels. Storage encryption protects the underlying stored bytes. E-File Magic adds application-layer envelope encryption for sensitive payloads, so protection is also part of how the application writes and reads those records.
Our envelope implementation uses AES-256-GCM, an authenticated encryption mode. It protects confidentiality and checks that the encrypted content and its associated context have not been altered. Account-scoped key material is itself wrapped by AWS KMS; stored key records contain the wrapped material rather than an unprotected key.
Context binding is particularly important in a system serving many organizations. Decryption checks the expected account and the relevant record or field context. Copying an encrypted value into a different account or record context does not make it valid there. AWS KMS also supports cryptographically binding encryption context to ciphertext, requiring matching context for decryption. [2]
Tenant records, processing snapshots, and service secrets have defined encryption and access boundaries. Key versions support controlled rotation, and key replacement must preserve the ability to read data that still depends on earlier material. Our design separates routine application work from authority to disable or delete the root keys.
Authorized E-File Magic services decrypt the information needed to validate records, produce forms, and carry out the services you request. Access controls and encryption context checks govern that processing, connecting data protection to the work your team needs to complete.
Search receives its own protection. For protected search terms, the system uses keyed cryptographic lookup tokens, known as HMACs, instead of putting the original sensitive value into the search index. A matching token helps locate a candidate record; normal account and permission checks still govern access to that record. This supports useful search while reducing unnecessary plaintext duplication.
Strong sign-in continues into the session
E-File Magic supports multi-factor authentication, passkeys, and organization single sign-on. The available flow follows the user's enrollment and account configuration. Passkeys use a cryptographic sign-in ceremony tied to the configured website identity; supported single sign-on lets an organization connect its identity provider.
For local password credentials, new password hashes use Argon2 with a random salt. Password hashing is a separate protection from encrypting tax records: the system verifies a submitted password against a derived value rather than storing it as readable text.
After sign-in, browser access remains bounded. Session cookies are protected from ordinary JavaScript access through HttpOnly, and session renewal uses server-validated capabilities that rotate. Idle and absolute expiry, revocation, and checks for stale or mismatched renewal attempts limit how a session can continue.
The workspace also accounts for real filing-team behavior: multiple tabs, inactivity, account switching, and a sign-in that expires while someone is editing. Reauthentication must confirm the intended user and account before the existing workspace resumes. These details help prevent convenience features from accidentally carrying one account's state into another.
Account isolation is enforced by the server
E-File Magic is a multi-tenant system: many customer accounts use the platform, while each account's business records have their own access scope. The backend derives that scope from authenticated identity, current membership, and permissions. A record ID, a browser-selected account, or a value supplied in a request is not permission by itself.
The same account boundary continues into data-access operations and encrypted-record handling. Filers, recipients, orders, payment instruments, and delivery records must be accessed in their authorized context. If a required identity, permission, or context check fails, the operation is rejected.
Team roles let organizations distinguish account administration from ordinary work. Integration permissions add explicit scope for connected applications. These logical boundaries let teams use a shared platform while keeping each account's work under its own authorization rules.
Support access has additional safeguards. Staff operations require appropriate roles and approved network access, and customer support sessions add stronger sign-in, a limited lifetime, and a specific account context. Recorded actions distinguish a support actor from the customer being helped. That attribution allows assistance without making the activity appear to have been performed by the customer.
Imported files are treated as untrusted input
Spreadsheets are convenient, but a filename alone cannot establish what a file contains. E-File Magic's import checks inspect the actual content and structure of supported files. The parser checks format and integrity within bounded limits rather than trusting an extension or the browser's file-type label.
Inspection can identify features such as macros, embedded objects, external connections, and suspicious formulas without executing the workbook. The system also supports independent malware scanning through AWS GuardDuty Malware Protection for S3. Security findings are associated with the exact uploaded file version, so replacing a file cannot reuse an earlier result.
Format checks and malware scanning have separate outcomes. An unavailable or unfinished malware scan is not described as a clean result. A confirmed malware finding quarantines the affected source and blocks subsequent access and import work. For ordinary imports, passing content checks does not mean every independent scan has completed.
These controls are designed to make file handling deliberate and traceable. They accompany the normal review of mappings and recipient values before filing. Our Excel integration guide explains the customer workflow.
Protecting the integrity of the work
Security also means protecting against unintended changes, partial updates, and duplicate actions. E-File Magic uses database transactions to commit related business changes together. Version checks detect when another process has changed a record since it was read, so a stale update can be rejected rather than silently overwriting newer work.
Operations with side effects use idempotency controls where applicable. In practical terms, a retry can be recognized as the same requested operation. This is valuable when a browser loses a response or a network connection fails at an uncertain moment.
Longer tasks use durable background workflows. Their progress is recorded outside the running process, workers claim bounded work, and completion is recorded. If execution is interrupted, recovery can start from the saved state. Retry limits, backoff, reconciliation, and paths for operational review keep failures visible.
Background requests also have an authentication boundary. Signed work messages and current durable state are checked before the system acts; a message containing an account identifier does not independently authorize work in that account.
For filings, the platform retains the relevant submission snapshots and provider outcomes. That history helps distinguish what was prepared, what was released, and what the IRS accepted or rejected. It also supports the continuity needed for eligible corrections. A successful save, a queued task, and an accepted return are different events, and the system is designed to preserve that distinction.
Recipient access is a protected workflow
Recipient delivery extends the security boundary beyond the filing team's account. A public document link is handled as a limited capability associated with a particular delivery, rather than permission to browse the customer's records. The backend validates that capability before providing the supported document context.
The recipient flow includes verification and consent before issuing a short-lived download session. Invalid attempts are limited, and expiry and revocation remain server decisions. Sensitive access tokens are kept out of the visible address bar after the page captures them, and download requests use the protected session.
The application records actual download activity separately from sending a notification. That gives the filer useful delivery evidence while maintaining the distinction between an email being sent, a form being downloaded, and a filing being accepted by the IRS.
A downloaded document becomes part of the recipient's or customer's own record-handling responsibilities. Use appropriate storage and sharing practices for exported copies. The Recipient E-Delivery guide and help finding a recipient form explain the practical flow.
Reducing unnecessary sensitive data
The safest copy of sensitive information is often the copy a workflow does not need to create. E-File Magic applies this principle through masked tax-ID presentation where appropriate, protected search terms, scoped responses, and redacted operational evidence.
Payment entry is another example. Card-number and security-code fields are hosted by the payment processor, with the application using the resulting payment token for the supported transaction. This keeps raw card entry separate from ordinary application fields. Payment records still retain the information needed for account and transaction management.
Audit and diagnostic information have their own handling rules. Protected record snapshots can be encrypted, while operational events retain the identifiers and outcomes needed for investigation. Sensitive content, credentials, and capability links do not belong in ordinary diagnostic messages.
Connected tools follow explicit access boundaries
Convenient integrations should preserve the account's security model. E-File Magic's API and MCP connections use authorized access, defined scopes, and current permission checks. Sensitive tax-ID and document capabilities are separately controlled, and connections can be revoked.
AI features also have distinct purposes. Public Milo answers from published guidance and cannot inspect customer accounts. Signed-in help operates within the authenticated experience. The AI-assisted spreadsheet column-matching feature reviews headers and mapping descriptions rather than workbook rows; that specific design reduces the information needed for its task.
An authorized assistant connection can prepare records within its granted access. Service selection, payment, filing agreements, and final submission remain with the person completing the normal checkout. The MCP introduction and Milo introduction explain these boundaries in more detail.
Security includes how software reaches the system
A well-designed application also needs a controlled path for change. E-File Magic's formal release workflow binds a release to a committed source revision and the exact application artifacts built from it. Cryptographic digests identify those artifacts, allowing promotion checks to verify the intended bytes.
The process produces a software bill of materials, or SBOM, and vulnerability-scan evidence. Unaccepted High or Critical findings block release sealing. Any supported risk acceptance must be specific, documented, and time-limited; it is not an open-ended instruction to ignore a scanner.
Database changes and one-time data repairs are tracked as ordered release work. Required repairs use bounded, resumable execution, and deployment records preserve the outcomes. Sealed release definitions are kept immutable, with corrections introduced through later releases.
These controls make a release reviewable: which source was used, which artifacts were built, which checks ran, and what happened during activation. They help keep software delivery subject to the same care as customer-facing workflows.
Accountability and resilience are part of protection
The application maintains append-only audit history for business changes, with actor attribution and request context. This supports investigation of who changed a record and which operation produced the change. Sensitive historical content remains subject to its encryption and access controls.
Operational monitoring complements that history. The infrastructure design includes service logs, metrics, and cloud activity records, while durable workflow state supports reconciliation after interruptions. Managed compute and storage let capacity grow with demand; bounded work and controlled concurrency help avoid overwhelming downstream services.
Availability is particularly important during filing season. Our design emphasizes preserving progress, recognizing incomplete work, and providing a controlled recovery path, so interruptions can be investigated and work can resume from its recorded state.
Retention and privacy commitments belong in the applicable policies and customer arrangements. Our Privacy Policy explains published information-handling terms, and Support can address organization-specific questions about records and review requirements.
Evaluate the platform with confidence
Our Security page also describes independent CPA review under SOC 2. If your organization needs assurance documentation, request the applicable report and confirm its type, covered service, review period, and scope with Support. A public architecture article helps explain the design; the report provides the specific independent-assurance evidence for your review.
The security knowledge-base article is the starting point for document requests, questionnaires, and privacy questions. Tell us what your organization needs and its review deadline so the team can identify the appropriate materials.
Your own account practices complete the day-to-day picture: use individual team access, keep authentication methods current, review connected applications, and store downloaded tax documents appropriately. If you notice a possible problem, our security-reporting guidance explains how to contact us privately.
For an individual business, these design choices support a careful path from imported records to delivered forms. For an accounting firm, they provide account boundaries, traceable activity, and recoverable processing across a larger filing program. For a technical reviewer, they provide concrete controls to evaluate.
E-File Magic brings those protections into the same workspace your team uses to prepare, review, file, and follow up. Explore the software tour, create an account, or contact our team to discuss how the platform fits your filing and security requirements.
PUT YOUR GUIDE INTO PRACTICE
Put your filing plan into practice.
Start with your reviewed records, or contact our team to confirm the services your filing needs.
Sources & further reading
Product documentation and official references supporting the design and features described in this guide.


