data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
interface Vehicle {
make: string;
model: string;
year: number;
start(): void;
stop(): void;
}
interface ElectricVehicle extends Vehicle {
batteryLevel: number;
charge(): void;
}
class Car implements Vehicle {
constructor(public make: string, public model: string, public year: number) {}
start() {
console.log(`${this.make} ${this.model} is starting...`);
}
stop() {
console.log(`${this.make} ${this.model} is stopping...`);
}
}
class ElectricCar extends Car implements ElectricVehicle {
batteryLevel: number;
constructor(make: string, model: string, year: number, batteryLevel: number) {
super(make, model, year);
this.batteryLevel = batteryLevel;
}
charge() {
console.log('Charging...');
this.batteryLevel = 100;
}
}
const myCar = new Car('Toyota', 'Corolla', 2021);
myCar.start();
myCar.stop();
const myElectricCar = new ElectricCar('Tesla', 'Model S', 2021, 50);
myElectricCar.start();
myElectricCar.stop();
myElectricCar.charge();
function showBatteryLevel(car: ElectricVehicle) {
console.log(`Battery Level: ${car.batteryLevel}%`);
}
showBatteryLevel(myElectricCar);
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
interface Vehicle {
make: string;
model: string;
year: number;
start(): void;
stop(): void;
}
interface ElectricVehicle extends Vehicle {
batteryLevel: number;
charge(): void;
}
class Car implements Vehicle {
constructor(public make: string, public model: string, public year: number) {}
start() {
console.log(`${this.make} ${this.model} is starting...`);
}
stop() {
console.log(`${this.make} ${this.model} is stopping...`);
}
}
class ElectricCar extends Car implements ElectricVehicle {
batteryLevel: number;
constructor(make: string, model: string, year: number, batteryLevel: number) {
super(make, model, year);
this.batteryLevel = batteryLevel;
}
charge() {
console.log('Charging...');
this.batteryLevel = 100;
}
}
const myCar = new Car('Toyota', 'Corolla', 2021);
myCar.start();
myCar.stop();
const myElectricCar = new ElectricCar('Tesla', 'Model S', 2021, 50);
myElectricCar.start();
myElectricCar.stop();
myElectricCar.charge();
function showBatteryLevel(car: ElectricVehicle) {
console.log(`Battery Level: ${car.batteryLevel}%`);
}
showBatteryLevel(myElectricCar);
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}
data() {
return {
title: 'My Vue App',
items: [] as Array<{ id: number; name: string; }>,
};
},
mounted() {
this.loadItems();
},
methods: {
async loadItems() {
const data = await fetch('/api/items');
this.items = await data.json();
},
addItem() {
const newItem = {
id: this.items.length + 1,
name: `Item ${this.items.length + 1}`,
};
this.items.push(newItem);
},
removeItem(id: number) {
this.items = this.items.filter(item => item.id !== id);
},
updateTitle() {
this.title = 'Updated Title';
},
clearItems() {
this.items = [];
},
sortItems() {
this.items.sort((a, b) => a.name.localeCompare(b.name));
},
reverseItems() {
this.items.reverse();
},
duplicateItems() {
this.items = [...this.items, ...this.items];
},
fetchMoreItems() {
// Fetch more items and add to the list
},
logItemCount() {
console.log(`Item count: ${this.items.length}`);
}
}

"App-Lösungen für jede Herausforderung"

Maßgeschneidert. Durchdacht. Wirkungsvoll.
App- und Webentwicklung mit erkoware solutions.

Strategiegespräch vereinbaren

Prozesse digitalisieren

Unsere App-Lösungen helfen dabei, manuelle Arbeitsabläufe in smarte, digitale Prozesse zu verwandeln, damit Ihr Unternehmen sich schneller an Veränderungen anpassen kann.

Abläufe automatisieren

Unsere maßgeschneiderten
App-Lösungen automatisieren wiederholende Abläufe in Ihrem Unternehmen. Genieße eine reibungslose Arbeitsweise und fokussiere dich auf das, was wirklich zählt.

Verbinden & Vernetzen

Unsere App-Entwicklungsdienstleistungen schaffen nahtlose Verbindungen zwischen verschiedenen Systemen, um Geschäftsprozesse zu optimieren und die Effizienz Ihres Unternehmens zu steigern.

Geschäftsmodelle erschließen

Unsere Strategien können Sie dabei unterstützen, innovative Geschäftsmodelle zu erschließen. Seien Sie Vorreiter in Ihrer Branche, transformieren Sie Ideen in Einnahmequellen und positionieren Sie Ihr Unternehmen für nachhaltigen Erfolg.

Referenzen & Einblicke

Weitere Projekte
Ausgewählte Projekte, die wir in enger Zusammenarbeit mit unseren Kunden realisiert haben.
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.

mom to be

Die Schwangerschafts-App mit den wirklich wichtigen To-Dos

mobile-app

Marketprint

Print-on-Demand Produktionsdigitalisierung und Shopify Shop

web-app, e-commerce, mobile-app

DHGS

Die DGHS-App bietet Mitgliedern Notfallhilfe durch Ausweise, SMS und Lebenszeichenservice.

mobile-app

motan

Die motan App vereinfacht die Zeiterfassung für Montageprojekte

cross-plattform-app, web-app

The Länd - Interaktiver Messestand

Wir haben für The Länd eine interaktive Web-App kreiert

cross-plattform-app

Octopus Order

Eine App - Alle Bestellungen

cross-plattform-app, web-app, e-commerce, mobile-app
Cross-Plattform App
Mobile App
E-Commerce
Web App

Wir bieten Ihnen

  • Individuelle App-Entwicklung zum fairen Preis
  • Zusammenarbeit mit Gründern, Startups und Unternehmen
  • Entwicklung unter Verwendung aktuellster Technologien
  • Ansprechpartner für alle Sachverhalte rund ums Thema Softwarelösungen
  • Ein kreatives, deutschsprachiges Team
  • Langfristige Betreuung der für Sie entwickelten Software

Mit einem Auge fürs Detail und einer Passion für Konzeption und die technische Umsetzung, stehen wir Ihnen aufIhrem Weg zur Seite.

5

Jahre Erfahrung

15+

Entwickler vor Ort

50+

Zufriedene Kunden

Wollen Sie mehr über uns erfahren?

Mehr erfahren
App-Entwicklung mit erkoware solutions
Wir begleiten Sie vom Konzept
bis zur Software-Pflege
Von der Ausarbeitung eines stimmigen Gesamtkonzepts, bis hin zum langfristigen Support.
Wir holen jedes Projekt an der Richtigen Stelle ab.
Planung & Consulting
Eine gut durchdachte Planung legt den Grundstein für effiziente Software.
Haben Sie Fragen oder sind sich unsicher, was eine geeignete Lösung für Ihr Problem sein könnte? Kein Problem, genau dafür sind wir da!
Um uns gewünschten Prozessen und den Anforderungen von Nutzern Ihrer Softwarelösung vollständig anzunehmen, bieten wir Ihnen unser Consulting an.  Bereits in diesem Prozess lassen sich die Ursachen von gegebenenfalls auftretenden Schwierigkeiten analysieren und vorbeugen.
Projektplanung & UI | UX Design
Damit es nicht nur gut aussieht, sondern auch funktioniert.
Nach der Festlegung des Funktionsumfangs, konzeptionieren unser Projektplaner einen User-Flow basierend auf Ihren Anforderungen, um die festgelegten Prozesse für Ihre zukünftigen Nutzer zu optimieren. Dieser Flow wird mit Ihnen besprochen und anschließend an das UI / UX Team und die Entwickler weitergegeben. 
Aufbauend auf festgelegte Planungen wird die Oberfläche in einem Prototyp gestaltet. Parallel definieren unsere Entwickler basierend auf Ihren technischen Anforderungen notwendige Schnittstellen und entwerfen die nötige Systemarchitektur.
Entwicklung
Fortschrittlich und durchdacht.
Erst mit dem entstandenen User-Flow, Prototypen und einer fertigen Systemarchitektur als Vorlage, starten wir in die Entwicklung Ihrer Software. Mit diesem Schritt stellen wir sicher, dass der Entwicklungsaufwand korrekt eingeschätzt und eine reibungslose Umsetzung ihrer Ideen unter Verwendung aller aktuellen Technologien gewährleistet werden kann.
Hosting & Support
Langfristig für Sie erreichbar.
Nach Abschluss der Entwicklung gilt es, Ihr Produkt zu veröffentlichen. Egal ob ein internes Rollout in Ihrer Firma, oder die Vertreibung über App-Stores, wir begleiten Sie durch diesen Prozess und stehen auch bei eventuellen zukünftigen Komplikationen langfristig an Ihrer Seite.
Auch um das Hosting Ihrer Software kümmert sich unser Team auf Wunsch gerne.
Kostenlos herunterladen!
Vielen Dank!
Oops! Geben Sie bitte Ihre Email Adresse erneut ein.

Häufig gestellte Fragen

Wie viel Zeit wird für die Entwicklung einer App benötigt?

Die Dauer der App-Entwicklung variiert je nach der Komplexität und dem Umfang des Projekts. Für einfache Anwendungen kann der Zeitraum von der Konzeption bis zur Markteinführung einige Monate betragen. Projekte mittlerer Größe benötigen typischerweise zwischen drei und sechs Monaten Entwicklungszeit.
‍
Komplexere Apps mit zahlreichen Funktionen und anspruchsvollem Design können jedoch bis zu einem Jahr oder in besonders komplexen Fällen sogar länger dauern. Effizientes Projektmanagement und ein qualifiziertes Entwicklerteam können den Entwicklungsprozess erheblich beschleunigen, sodass Ihre App zügig und erfolgreich umgesetzt wird.
‍
Als Ihr Partner bringen wir die notwendige Expertise und Erfahrung mit, um Ihr Projekt von der Idee bis zur Markteinführung professionell zu unterstützen und sicherzustellen, dass Ihre Vision wirkungsvoll und effizient realisiert wird.

In welchem Kostenbereich bewegt sich die Realisierung einer App?

Die Kosten für eine App, werden grundsätzlich basierend auf dem zugrundeliegenden Aufwand berechnet.
Wir erstellen zunächst gerne einen möglichst genauen Kostenvoranschlag, welcher im Regelfall mit nur geringen Abweichungen eingehalten wird. Bei größeren Änderungen am Umfang oder der Projektspezifikation während der Projektlaufzeit besprechen wir diese und die damit verbundenen Kosten transparent mit Ihnen.

Über unseren Kostenrechner können Sie sich eine erste Einschätzung einholen.

Wie verrechnen Sie ein Projekt? Vorauszahlung, Zahlung in Etappen, jeweils nach Abnahme der Meilensteine, am Ende, etc.?

Im Regelfall berechnen wir eine Vorauszahlung von 30% des gemeinsam angesetzten Projektbudgets und anschließend monatliche Zahlungen, gekoppelt an den Projektfortschritt bzw. an die Meilensteine.

Welche Erwartungen haben Sie an uns um erfolgreich arbeiten zu können?

Um Projekte erfolgreich abschließen zu können, legen wir besonders großen Wert auf eine offene und produktive Zusammenarbeit. Besonders Einblicke in die Prozesse und Herausforderungen, für die Sie Ihr Projekt entwickeln wollen, helfen uns, Ihr Projekt zu implementieren und ihnen den bestmöglichen Service zu bieten. Je klarer Sie Ihre Anliegen und Anforderungen kommunizieren, desto leichter und schneller kann der Entwicklungsprozess verlaufen.

Selbstverständlich verstehen wir, dass es während der Konzeption zu Veränderungen von Anforderungen kommen kann. Diese erarbeiten wir in einer gemeinsamen Planungsphase gerne mit Ihnen und unterstützen Sie bei der Festlegung des Funktionsumfangs.

Gewähren Sie eine Garantiefrist?

Für durch unsere Programmierung verursachte Fehler gewähren wir eine Garantiefrist von 12 Monaten, innerhalb derer wir diese Fehler kostenfrei beheben. Eventuelle Probleme, welche beispielsweise durch Updates des Betriebssystems, andere nicht von uns entwickelte Komponenten oder durch nicht korrekte Spezifikationen entstehen, beheben wir gerne im Rahmen einer Wartungsvereinbarung.

Wird bei Ihnen alles Inhouse programmiert oder zum Teil/gänzlich im Ausland?

Wir arbeiten für die meisten Projekte ausschließlich mit unserem In-House Team in Deutschland. Bei speziellen Anforderungen oder sehr großer Projektgröße haben wir aber zusätzlich die Möglichkeit, weitere Experten von einem Partner im EU-Ausland in das Projekt aufzunehmen, sofern dies erwünscht ist.

Können wir den Entwicklungsstand (inkl. Code) jederzeit online überprüfen?

Sie bekommen einen Zugriff auf aktuelle Testversionen der Anwendung. Auf Wunsch können Sie ebenfalls Zugriff auf den aktuellen Quellcode im Git erhalten.

Wann hätten Sie Kapazitäten, mit unserem Projekt zu starten?

In der Regel ist es uns innerhalb von 1 - 2 Wochen nach einer Projektzusage möglich, einen Kick-Off Termin zu vereinbaren und mit der Planungsphase zu starten. Der Entwicklungsstart erfolgt meist direkt im Anschluss an die Planungsphase, abhängig vom genauen Datum der Projektzusage.

Kostenloses Erstgespräch
Angebots-Präsentation
Projektstart

Schritt #1

Kostenloses Erstgespräch

Dauer: ca. 30 - 60 Minuten
Und dann: Wir erstellen Ihr Angebot!
Erzählen Sie uns von Ihrem Projekt, Ihrer Idee oder Ihrem Problem. Bekommen Sie ein Gefühl für unsere Firma und entscheiden Sie, ob Sie sich eine Zusammenarbeit mit uns vorstellen können. Wir können Ihnen eine erste Einschätzung zur technischen Umsetzung geben und Ihr Projekt in Bezug auf Aufwand und Kosten einordnen.

Schritt #2

Angebots-Präsentation

Dauer: ca. eine Stunde
Und dann: Ihr "Go" gibt den Startschuss!
Basierend auf Ihren Anforderungen präsentieren wir Ihnen eine erste Konzeption und besprechen unsere Überlegungen. Dabei klären wir auch, wie die Zusammenarbeit aussehen wird, inklusive Kommunikation und Abläufen. Sie erhalten ein maßgeschneidertes Angebot, das den Projektumfang, die Kosten und den zeitlichen Aufwand transparent darstellt.

Schritt #3

Kick-Off: Projektstart

Dauer: je nach Umfang ca. 2-6 Monate bis zur ersten Version
Und dann: Wir tun, was wir am besten können!
Ihre Angebotsbestätigung ist unser Startschuss. In einem Kick-Off-Workshop legen wir die finale Projektplanung inklusive Funktionsumfang fest und starten mit dem User-Flow und Prototypen. Parallel modellieren unsere Entwickler die technische Basis für Ihr Projekt.  Sie behalten dabei jederzeit den vollen Überblick über den Fortschritt und die nächsten Schritte.

Get in Touch

Termin vereinbaren
Kontaktformular
Vielen Dank! Wir haben deine Anfage erhalten und melden uns bald bei Ihnen.
Ups! Beim senden Ihrer Anfrage ist etwas schief gelaufen. Laden Sie die Seite neu und versuchen Sie es erneut.

Ihr zuverlässiger Partner für maßgeschneiderte Softwarelösungen und digitale Transformation. Wir stehen für Innovation, Effizienz und nachhaltigen Erfolg in Ihrer digitalen Zukunft.

© 2024 erkoware solutions

App EntwicklungCasesÜber UnsDatenschutzImpressum
Bahnhofsstraße 8, 87435 Kempten
+49 831 / 69726315
service@erkoware.de
app-entwickler-verzeichnis
appfelsine Partner
No items found.