Skip to content

DVision SoftwareIT Solutions

Software that ships - and stays healthy

Hands-on engineering from greenfield to rescue - build, stabilize, and keep it healthy.

Services

What I do for clients

Seven clear offers - consulting, development, audit, ops, and AI. Expand any one for details.

I help founders, CTOs, and product teams lock architecture and delivery choices with practical judgment. Blank-page start or mid-project chaos - the outcome is a plan your team can execute, with trade-offs stated plainly.

Deliverables

  • Architecture recommendation with alternatives and trade-offs
  • Delivery plan with milestones and risk callouts
  • Stack and tooling guidance aligned to your constraints
  • Standards and review habits your team can keep after I leave

Who it’s for

  • Founders validating a product and stack before hiring a full team
  • CTOs and leads who need an experienced peer for architecture choices
  • Teams stuck between keep building and stop and redesign

Included work

Greenfield framing

Clarify goals, constraints, and success criteria. Shape the first architecture, stack, and milestones before code sprawl sets in.

System shape & boundaries

Frontend/backend boundaries, multi-app strategy, API shape, scalability, and maintainability - designed for how your team actually ships.

Stack calls

Frameworks, hosting, CI/CD, and libraries evaluated against cost, team skill, timeline, and long-term ownership - with one clear recommendation.

Delivery steering

Technical direction, priorities, engineering standards, and unblocking - so the team moves with less thrash.

Turnaround & rescue

Enter mid-project chaos, find root causes, stabilize delivery, and redefine architecture and process where needed.

Mentoring & handover

Elevate practices through reviews, pairing, and documentation habits that survive after the engagement ends.

I build positioning-driven websites and landing pages with the same discipline I apply to product work: clear structure, strong performance, semantic HTML, and CTAs that match how buyers decide.

Deliverables

  • Page structure mapped to offers and proof
  • Implemented responsive site or landing page
  • Technical SEO basics (meta, routes, sitemap-ready structure)
  • Performance-minded frontend (Core Web Vitals aware)

Who it’s for

  • Teams launching or refreshing a public site
  • Founders who need a credible web presence before sales conversations
  • Products whose site looks fine but fails on speed, structure, or clarity

Included work

Company & product sites

Sites that communicate who you are, what you sell, and why someone should trust you - with hierarchy that guides action.

Launch & offer pages

Focused conversion pages for offers, campaigns, or launches - one job, one clear next step.

Speed & SEO structure

Core Web Vitals, lean assets, routes, metadata, and crawl-friendly architecture.

Visual system for the web

Reusable visual language across public site and product so the brand feels intentional.

I build and extend product surfaces: Angular and React applications for web and desktop, design systems, realtime features, migrations, and ongoing feature delivery. Typed code, clear structure, UI that respects users and the next owner.

Deliverables

  • Production-ready features or applications
  • Typed, structured codebase with modern Angular/React patterns
  • Reusable UI where it pays off
  • Handover notes and maintainable defaults

Who it’s for

  • Teams needing a senior engineer for a critical slice of work
  • Companies migrating or modernizing Angular/React applications
  • Products that need design-system consistency across multiple apps

Included work

Web & desktop applications

Angular-first preference with modern APIs; React when the product context calls for it. TypeScript everywhere - including desktop apps built with web technologies.

Shared UI systems

Reusable UI primitives and multi-app consistency - informed by real design-system maintenance experience.

Realtime features

Chat, presence, live updates, and client UX - grounded in years of realtime platform work.

Migrations & modernizations

Angular upgrades, React migrations, legacy UI rewrites, and backend cutovers without freezing the business.

Feature stream & care

Ongoing delivery, bug fixing, and reliability improvements so products stay healthy after launch.

I review code, architecture, performance, privacy/security baselines, dependencies, and delivery process. You get a clear risk map and a remediation order your team can act on immediately.

Deliverables

  • Findings ranked by severity and business impact
  • Evidence-backed notes (not vague opinions)
  • Remediation roadmap for 30 / 90 days
  • Optional follow-up implementation support

Who it’s for

  • Leaders inheriting a codebase they do not fully trust yet
  • Teams preparing a major rewrite, raise, or vendor decision
  • Products with recurring quality, performance, or release pain

Included work

Code quality pass

Readability, patterns, testing gaps, and maintainability risks that slow every future change.

Architecture stress check

Coupling, boundaries, scalability bottlenecks, and abstractions that fight the product.

Performance pass

Load, rendering, bundle size, API latency, and caching - measured and explained.

Security & privacy baseline

Auth surfaces, data handling hygiene, common exposure risks, and GDPR-aware practices - practical, not theatrical.

Dependency & debt map

Outdated libraries, upgrade risk, and a prioritized debt map.

Delivery friction review

Branching, CI/CD health, release friction, and ownership gaps that create silent delay.

I set up and maintain the practical ops surface around web products: Linux service layout, Nginx and reverse proxy routing, SSL, domains, proxy/traffic control, and CI/CD pipelines. Reliable deploys, fewer production surprises.

Deliverables

  • Working server / proxy / SSL configuration
  • Documented environments (staging/prod discipline)
  • CI/CD flow that matches how you release
  • Operational notes your team can follow

Who it’s for

  • Teams without a dedicated DevOps hire who still need production discipline
  • Products outgrowing ad-hoc hosting and manual releases
  • Companies needing Nginx/proxy/SSL ownership and CI/CD cleanup

Included work

Server layout & hygiene

Linux environments, service layout, and operational hygiene for web workloads.

Nginx / reverse proxy / SSL

Domains, certificates, routing, HTTPS, and secure traffic handling for public apps.

Proxy & traffic control

Proxy configuration experience (including Squid-style setups) for reliable, controlled traffic paths.

CI/CD ownership

Pipeline design and maintenance (Drone and similar), build scripts, and deploy flow that reduces release fear.

Domains & environments

Staging/prod separation and configuration discipline so environments stop surprising you.

Ongoing runtime care

Stability work, monitoring mindset, and incident-response support when things drift.

Sometimes the hardest part is not writing code - it is deciding whether the current plan is sound. I validate, challenge, and recommend with clear reasoning your stakeholders can use.

Deliverables

  • Independent assessment of the proposed path
  • Risks, assumptions, and missing information called out
  • Recommended next step (and what not to do)
  • Stakeholder-ready summary

Who it’s for

  • Founders and managers facing a major build/buy/rewrite decision
  • Teams split between conflicting technical proposals
  • Stakeholders who need a plain-language recommendation

Included work

Architecture review

Validate or challenge a proposed design before you invest months into it.

Stack & estimate sanity

Is the proposed approach realistic and proportional to the problem and budget?

Project health snapshot

What is actually wrong, what is noise, and what should change next week.

Decision brief for stakeholders

Clear written recommendation for founders, managers, or investors - without internal politics.

Rewrite vs recover

Redesign vs rewrite vs incremental recovery - with a plan that matches constraints.

I help you add AI where it creates leverage: integrate models and APIs into existing products, design AI-assisted workflows, build UI around generation and review loops, and keep quality, cost, and privacy under control. From first experiment to maintainable production feature.

Deliverables

  • Use-case framing and feasibility notes
  • Working integration or feature in your stack
  • Prompt/tooling structure and failure handling
  • Operational notes: cost, rate limits, privacy, rollback

Who it’s for

  • Product teams adding AI features into an existing Angular/React app
  • Founders who need an AI capability without a research circus
  • Companies that tried a prototype and now need a reliable integration

Included work

AI feature design

Find where AI actually helps - assisted drafting, search, classification, support flows - and where it should stay out.

Model & API integration

Wire OpenAI/compatible APIs or other providers into your backend/frontend with auth, retries, and streaming where needed.

AI-assisted product UI

Build the human loop: generate, review, edit, approve - so AI output is usable inside real workflows.

Internal AI tooling

Assist teams with internal copilots, content helpers, or ops assistants wired to your data and processes.

Quality, cost & safety

Eval hooks, logging, rate limits, PII hygiene, and fallbacks so AI features stay controllable in production.

AI in existing apps

Add AI capabilities into current Angular/React products without a rewrite - incremental, testable, shippable.

Skills

Stack and craft

Production tools and judgment calls - grouped by how work actually gets done, not by buzzword bingo.

01

Frontend & product UI

Product interfaces built for clarity, consistency, and long-term maintainability.

  • Angular
  • React
  • TypeScript
  • Stencil.js
  • Design systems
  • Component libraries
  • HTML & SCSS
  • Tailwind CSS
  • Angular Material
  • RxJS
  • NgRx
  • Responsive design
  • Accessibility
  • Next.js
  • CSS Modules
  • Web Components
  • Form architecture
  • Internationalization
  • Progressive web apps
  • Server-side rendering
  • Data visualization
  • UI motion design
02

Architecture & delivery

Technical structure and delivery decisions that keep teams shipping with control.

  • Frontend architecture
  • Multi-application systems
  • Realtime applications
  • Platform migrations
  • System design
  • Technical leadership
  • API architecture
  • Engineering standards
  • Performance engineering
  • REST APIs
  • GraphQL
  • Integration design
  • Domain modeling
  • Backend architecture
  • Identity and access
  • Caching strategy
  • Resilience patterns
  • Scalability planning
  • Monorepo architecture
  • Module boundaries
  • Technical debt management
  • Release planning
03

Platform & operations

Reliable path from commit to production - services, data, and infrastructure.

  • CI/CD
  • Drone
  • Nginx
  • Squid proxy
  • Linux
  • SSL and domains
  • Node.js
  • Shell scripting
  • Code signing
  • NestJS
  • Express
  • PostgreSQL
  • Redis
  • Docker
  • Secrets management
  • MongoDB
  • Prisma
  • TypeORM
  • OAuth 2.0
  • JWT
  • Message queues
  • Background processing
  • GitHub Actions
  • Cloudflare
  • Load balancing
  • Observability
  • Backup and recovery
04

Tooling & quality

Build systems, collaboration, and quality controls that protect production software.

  • Vite
  • npm
  • pnpm
  • WebSocket
  • Storybook
  • Git
  • Web and desktop clients
  • GDPR compliance
  • Application security
  • Jira
  • Confluence
  • ESLint
  • Prettier
  • Jest
  • Playwright
  • OpenAPI
  • Swagger
  • Webpack
  • Cypress
  • Testing Library
  • Git hooks
  • Static analysis
  • Postman
  • Browser DevTools
  • Bundle analysis
  • Dependency auditing
  • Code review process

Work

Six years engineering production software

Delivering applications, shared frontend systems, and release infrastructure for product teams - with code and decisions that hold up after handover.

Web & desktop application development

Feature ownership on Angular and React codebases - TypeScript, modern UI patterns, and code that stays maintainable after handover.

Shared frontend systems

Design systems and component libraries shared across product surfaces - consistency without duplicated UI work.

Realtime & multi-user products

Live multi-user clients where reliability and ongoing maintenance matter as much as the first release.

Servers, CI/CD & traffic layer

Linux, Nginx, SSL/domains, proxy routing, and CI/CD so releases stay predictable.

Architecture & delivery guidance

Stack choices, system shape, and standards when a team needs a clear technical path.

Long-running product care

Ongoing features, migrations, fixes, and stabilization on systems that already have users and deadlines.

Proof

Selected outcomes

Anonymized production work - sector, pressure, move, and a concrete before → after signal.

SaaS1 systemShared UI across product surfaces
Rescue< 2 weeksFrom chaos to a clear recovery path
OpsCI → prodRelease path made routine
RealtimeDay-twoLive multi-user product kept healthy
SaaS / platform

Shared UI system

Several apps → one design system

Before

Several product surfaces shipping in parallel - UI drift, duplicated components, no single source of truth.

Move

Shipped a shared design system and component library the teams could own and extend.

After

One visual language, faster feature UI, and far less copy-paste frontend work.

Rescue

Mid-flight recovery

Diagnose → plan in days, not months

Before

Project already moving - fuzzy architecture calls, slipping quality, no honest path to green.

Move

Diagnosed root causes, contained risk, and replaced chaos with a prioritized recovery sequence.

After

A stable decision path - recover, redesign, or rewrite - instead of a panic rewrite.

Ops / delivery

Release hardening

Habit deploys → repeatable pipeline

Before

App was live, but deploys and the traffic layer depended on habit - SSL, proxies, pipelines.

Move

Hardened Linux, Nginx, SSL, routing, and CI/CD until release was routine.

After

Predictable deploys and an ops layer the team could run without tribal knowledge.

Realtime product

Live product care

Launch care → continuous care

Before

Multi-user product where reliability and day-two maintenance mattered as much as launch.

Move

Owned client UX and integrations with production discipline - not a demo spike left behind.

After

A live surface that stayed maintainable under real users and continuous change.

Why DVision

Why choose DVision

Senior delivery without the agency fog - proven across 5+ clients and 20+ projects in production.

0+Clients
0+Projects
0yProduction work
0Services offered
SIGNAL

You talk to the person who ships

No account managers, no relay chain. Architecture calls and implementation come from the same hands.

RANGE

Greenfield to rescue, same standard

New builds, stuck mid-flight projects, audits, and ops - one senior bar instead of handing you between specialists.

OWN

Work your team can keep

Clear decisions, documented handover, and code shaped for the people who maintain it after I leave.

REAL

Production over theater

Client and project work taught the same lesson: demos don’t matter. Reliable software in the wild does.

Process

How an engagement runs

Same spine for greenfield builds, audits, infrastructure, and rescue work.

  1. 01

    Discover

    Goals, constraints, stakeholders, and what “done” means. Enough clarity to act - no theater.

  2. 02

    Diagnose / plan

    Risks, architecture options, and a delivery plan. On rescue work, this is where chaos becomes a sequence.

  3. 03

    Build / stabilize

    Execute with visible checkpoints and honest status - features, sites, pipelines, audits, or architecture changes.

  4. 04

    Hand over

    Documentation and knowledge transfer so your team owns the outcome after the engagement.

About

Software Engineer & Consultant

Darko Vulicevic

Owner of DVision Software & IT Solutions. Consultant and engineer focused on production software - hands-on build, architecture judgment, and direct communication with the people who own the product.

Build it clean. Keep it healthy. Own the outcome.

Clarity over theater

Trade-offs in plain language. You always know what I recommend and why.

Ship, then keep it healthy

Launch matters - so does day two. I build for the team that maintains the work next.

Stabilize before you rewrite

Chaos rarely needs a full rewrite on day one. Diagnose, contain risk, then modernize with intent.

Senior hands, not black boxes

Direct engineering and advice - transparent progress, no agency fog.

Engagement

What clients can expect

Clear terms, senior execution, and ownership that stays with your team.

Honest framing up front

Scope, timeline, and trade-offs stated early - before work starts, not after pressure builds.

Modern TypeScript engineering

Angular or React when it fits your constraints - maintainable production code, not stack theater.

Documented handover

Clean handoff your team can operate and extend without relying on a black box.

Direct access

Founders, CTOs, and product owners talk to me - no account-manager relay in between.

FAQ

Straight answers before we talk

Scope, stack, rescue work, and how engagements start - the questions clients ask most before a call.

Stack decisions follow your product constraints, team skills, and existing codebase - not a preferred toolkit. I recommend what fits the delivery risk and long-term ownership, then execute against that choice.

Still unsure if this is the right fit?

Contact

Tell me what you’re building - or repairing

Share the project stage and the service lane that fits.

You talk to the person who ships - architecture and implementation from the same hands.

How engagements with DVision usually feel
Open for Q1 2027--:--
  • Email
  • ResponseUsually replies within 1–2 business days
  • AvailabilityAvailable remotely · Europe timezone
  • LanguagesEnglish · Serbian

For a useful first reply, include

  • Goal and where the project stands now
  • Stack, constraints, and who decides
  • Timeline and how urgent it is

Privacy

This website is operated by Darko Vulicevic. It is a business marketing site. I collect only what you voluntarily send through the contact form (name, email, optional company, service interest, project stage, and message).

Contact submissions are emailed to me so I can reply to your inquiry and manage potential engagements. They are not sold. Form delivery is handled by a form-to-email provider under their terms.

Basic technical logs may be created by hosting providers for security and reliability. If analytics are added later, this page will be updated.

Questions: darkov.office@gmail.com