Staff Frontend Engineer. Frontend architecture. Product delivery. Security by design.

Frontend leadership that keeps products shipping

I work with frontend as an engineering system. I focus on architecture decisions. I focus on delivery reliability. I focus on team practices. Long term maintainability guides every choice.

Contact Case studies LinkedIn m.lepickis@gmail.com

Architecture that survives growth

Clear boundaries. Incremental change. Evolution paths that avoid rewrites.

Delivery system, not heroics

CI and CD practices that make shipping routine. Quality gates stay lightweight.

Security by design

Practical controls embedded into UI design. Reviews reinforce secure defaults.

Focus

My work sits at the intersection of frontend engineering and product thinking. Delivery systems are a core concern. I focus on how teams build products. I focus on how products evolve over time.

What I do

  • Frontend architecture designed to support growth without forcing rewrites.
  • Roadmap decisions based on risk, effort, long term cost.
  • Team practices that improve ownership. Review quality improves as a result. Decision making becomes clearer.
  • Performance treated as a continuous product concern.
  • Security integrated into design. Implementation follows the same principles. Reviews reinforce them.

How I operate

  • I start from risk constraints. I treat compliance as a design requirement.
  • I account for UX costs. I protect delivery timelines.
  • I prefer incremental modernisation. I avoid rewrites unless the trade off is clear.
  • I document decisions through principles, ADRs, definitions of done.
  • I build feedback loops through metrics, alerts, postmortems, improvements.
Ownership Roadmap Architecture Delivery Security Performance

Scope

I have worked on products where mistakes are costly. I have also worked on systems where speed matters to user trust.

Regulated environments

Compliance constraints shape UI design. Security posture stays explicit.

High stakes flows

Identity, onboarding, payments, transactional journeys. Failure handling stays deliberate.

Embedded surfaces

Partner widgets, iframe based integrations, contract stability. Compatibility stays predictable.

Case studies

These examples avoid confidential detail. They focus on decisions. They focus on constraints. They focus on outcomes.

From release events to routine shipping

Context

Delivery relied on manual coordination. Release cycles created stress. Risk increased as the team grew.

Constraint

The product had to keep shipping. A delivery freeze was not acceptable.

Action

I introduced trunk based development. I defined lightweight quality gates. Teams aligned around a shared definition of done.

Outcome

Shipping became routine. Risk became predictable. Delivery speed stabilised.

Incremental architecture without rewrites

Context

The product required faster iteration. The codebase showed structural limits.

Constraint

A rewrite was not an option. Business delivery had to continue.

Action

I designed an incremental architecture path. Boundaries became explicit. Work was sequenced through roadmap milestones.

Outcome

Architecture improved steadily. Delivery remained stable throughout the change.

Performance as a system constraint

Context

Performance degraded over time. Discussions relied on opinion rather than data. Regressions shipped silently.

Constraint

Feature development could not slow down. Performance had to improve in parallel.

Action

I introduced performance budgets. Profiling became part of regular work. Monitoring exposed regressions early.

Outcome

The product stayed fast during feature growth. Performance discussions became objective.

Embeddable flows with strict boundaries

Context

The product relied on embeddable flows. Widgets ran inside partner controlled environments.

Constraint

Partner environments could not be trusted. The surface area had to stay controlled.

Action

I used iframe isolation. Messaging contracts became explicit. Backend state recovery aligned with frontend behaviour.

Outcome

Integrations became more reliable. Security posture improved. Support load decreased.

Background

I grew from individual contributor into frontend engineering leadership within a regulated fintech product. My focus stayed on architecture decisions. My focus stayed on delivery systems. My focus stayed on team maturity.

B2C and B2B experience

I have worked on consumer facing products. I have also built systems for partners and internal teams. Each context has different constraints. Engineering discipline stays the same.

B2C

  • Conversion critical journeys with friction from fraud controls.
  • Speed as an acquisition factor. Stability as a retention factor.
  • UX decisions shaped by trust. Error handling stays explicit.

B2B

  • Contract stability through versioning discipline.
  • Operational clarity through permissions, auditability, predictable UI behaviour.
  • Integrations that favour correctness. Rollouts protect compatibility.

Widgets and embeddable flows

I have built embeddable solutions such as on ramp and off ramp flows. These systems require coordination between frontend and backend. Integration quality determines product trust.

Architecture and contracts

  • Clear integration contracts with versioning. Rollouts protect partners.
  • State modelling that supports retries. Recovery stays explicit.
  • Observability that supports funnels. Errors stay actionable.
  • Asset delivery tuned for fast startup. Public assets stay cacheable.

Delivery responsibilities

  • Integration points designed through callbacks, redirects, webhooks.
  • UI and API components built to evolve together.
  • Partial failures handled explicitly. Retries stay bounded.
  • Support tooling built for operators. Diagnosis stays fast.

Frontend security

I treat security as part of system design. The goal is risk reduction without breaking delivery flow.

Security mechanisms

  • Cross site scripting prevention through strict rendering rules. Safe defaults reduce exposure.
  • CSRF aware flows with explicit session boundaries. Authentication state remains predictable.
  • Cryptographic signature generation for sensitive requests. Signature based verification protects critical flows.
  • Dependency risk management through controlled upgrades. Supply chain hygiene stays routine.
  • Secrets hygiene enforced at build and runtime. Sensitive state stays out of URLs.

Infrastructure and decision logic

  • Domain allowlists enforced at the edge. Frontend accepts traffic only from trusted origins.
  • Header based validation for environment checks. Requests are evaluated before business logic.
  • Soft denial decisions applied under uncertainty. Flows continue with reduced capability or additional verification.
  • Hard denial decisions applied on confirmed risk. Requests are blocked immediately.
  • Decision making driven by data. Metrics and audit logs support investigation and tuning.

Toolbox

Tools matter less than decisions. I work best in the Vue and Nuxt ecosystem. I have strong backend context with PHP. I use Symfony for API work.

Frontend

JavaScript. TypeScript. Vue. Nuxt. SPA. SSR. SSG. Performance work.

Backend context

PHP. Symfony. API design. Security constraints. Integration patterns.

Engineering system

CI. CD. Trunk based development. Quality gates. Monitoring. Team practices.

Contact

If you need someone who can own frontend architecture and delivery as part of a product, feel free to reach out.

Email LinkedIn Back to top