Abdelrahman Hegab
Download CV
Back to Projects

Case Study

Upland FileBound

Enterprise SaaS · Document & Workflow Automation

Nearly five years contributing across backend APIs, integrations, workflow, eForms, security, performance, testing infrastructure, and production support on a mature enterprise SaaS platform.

  • .NET
  • ASP.NET MVC/Web API
  • SQL Server
  • Dapper
  • Angular
  • SaaS
  • Integrations

Overview

FileBound is a mature enterprise SaaS platform for document management, workflow automation, electronic forms, integrations, and business-process automation.

I contributed to the product for nearly five years as part of a distributed engineering engagement with Upland Software. The work required balancing feature delivery with backward compatibility, technical debt, security, performance, and the reliability expectations of a long-lived production system.

Its mixed architecture reflected years of product evolution: established ASP.NET MVC and Web API applications operated alongside a newer API layer, a WPF workflow designer, legacy web interfaces, and a newer Angular 16 MobileView area using NgRx and RxJS.

Technical context

  • Backend and APIs: C#, .NET Framework 4.5.2 and 4.8, ASP.NET MVC 4, ASP.NET Web API 2, OWIN, and Autofac.
  • Data access: Microsoft SQL Server, Dapper, and hand-written parameterized SQL.
  • Web applications: Razor, TypeScript, jQuery, and Angular 16 with NgRx and RxJS for the newer MobileView area.
  • Workflow and integrations: a WPF workflow designer, REST APIs, DocuSign, and HelloSign.

My Contribution

I joined as the first FlairsTech engineer assigned specifically to the FileBound account and remained involved as the FlairsTech engineering team grew to approximately 15 developers and later beyond that size. This was senior-engineer responsibility in a collaborative team, not formal people management.

My contribution spanned product features and the engineering work needed to keep them dependable in production. I owned delivery of specific changes while working within established product conventions and shared review practices.

  • Backend services, API v1 and v2 endpoints, SQL-backed data access, and database changes.
  • Workflow, eForms, anonymous-form behavior, document operations, reporting, and viewer functionality.
  • Electronic-signature integrations, security hardening, performance improvements, and production troubleshooting.
  • Integration tests, peer review, and technical discussion across shared patterns and code paths.

Selected Engineering Challenges

The highest-signal work was rarely isolated to one controller or screen. It involved tracing behavior across product layers, preserving established contracts, and making changes that were safe for existing workflows.

Multi-queue workflow sorting and filtering

Adding sorting and filtering to workflow steps with multiple queues crossed the WPF workflow designer, backend and data-access code, persistence, web widgets, and integration tests. The challenge was to evolve the behavior without breaking existing workflow conventions.

  • Coordinated domain, persistence, desktop, and web behavior as one feature rather than as disconnected changes.
  • Worked iteratively as compatibility constraints and regression scenarios became clearer.
  • Kept integration coverage aligned with the evolving workflow behavior.

eForms and anonymous access

Electronic-form work covered parent and child behavior, revisions, published-version visibility, anonymous access, success-page behavior, and session isolation. These flows combined product rules with authentication, privacy, and state-management concerns.

  • Resolved a defect that could surface anonymous-form data across separate sessions.
  • Corrected access-flow behavior for an anonymous-form URL scenario so the expected login experience was preserved.
  • Maintained form-link and published-version behavior while working within existing compatibility constraints.

API & Integration Engineering

I worked across legacy and newer REST API layers, including CRUD endpoints, field and metadata APIs, business-intelligence data-source APIs, anonymous-form resources, integration resources, and document-count behavior. The Dapper-based data layer made query correctness, parameterization, mapping, migrations, and integration coverage part of API delivery.

Full-stack API slices

A business-intelligence data-source feature is one example of end-to-end ownership: it required new database structures, data-access factory support, API v2 behavior, and tests. The work followed existing controller and factory patterns so the addition remained consistent with the mature codebase.

Electronic-signature reliability

I maintained DocuSign and HelloSign integrations, including compatibility work when an external authentication model changed. The response combined OAuth-related changes with controlled retry and error-handling behavior so external failures remained diagnosable and production-safe.

Security, Performance & Production Quality

Production support shaped the design of everyday changes. Defensive input and output handling, controlled failures, backward compatibility, and careful regression analysis were part of feature work rather than a separate final phase.

Security hardening

  • Hardened multiple dashboard widgets against cross-site scripting risks.
  • Implemented allow-list based validation for uploaded file extensions.
  • Addressed authentication, access-flow, and session-isolation defects in anonymous-form scenarios.

Reducing repeated settings queries

Application settings were read broadly enough that repeated database access became a cross-cutting concern. I introduced an in-process cache inside the existing settings data-access layer and added an early-exit path when extended data was not required. Consumers kept the same contract while avoidable database round trips were removed.

Controlled production behavior

  • Resolved workflow routing that could incorrectly send documents into exception handling during multi-load processing.
  • Improved a locked-document scenario so it produced a controlled user-facing response instead of an unhandled error.
  • Corrected viewer, reporting, audit, and document-operation defects where reliability depended on details across several layers.

Testing & Engineering Infrastructure

I worked extensively with, contributed to, and expanded reusable integration-test infrastructure around the data-access layer. Entity-specific fixtures, setup and cleanup helpers, and repeatable database-backed tests gave API and persistence changes a consistent verification path.

The shared Reaper infrastructure predated my contribution. My role was to use and extend its reusable patterns across multiple entities and complex production scenarios as part of a collaborative engineering team.

Code quality was also shared through peer review. Pull requests required approval from two senior-or-above engineers, and I regularly reviewed other engineers' work while receiving the same review on my own changes.

What This Work Demonstrates

FileBound reinforced that senior engineering in a mature platform is often about choosing the safest effective change, understanding how behavior crosses boundaries, and improving the system without turning every problem into a rewrite.

  • Pragmatic modernization: contributing to newer API and Angular areas while respecting legacy contracts and production constraints.
  • Cross-layer ownership: carrying workflow, API, data, integration, and user-facing changes through verification.
  • Defensive production engineering: treating security, failure handling, privacy, and backward compatibility as design concerns.
  • Collaborative technical leadership: using peer review, shared testing patterns, and technical discussion to improve consistency and delivery confidence.