Data Summit 2025 is just around the corner, and we’re excited to connect, learn, and share ideas with fellow leaders in the data and AI space. As the pace of innovation accelerates, events like this offer a unique opportunity to engage with peers, discover groundbreaking solutions, and discuss the future of data-driven transformation.
We caught up with Jerry Locke, a data solutions expert at Perficient, who’s not only attending the event but also taking the stage as a speaker. Here’s what he had to say about this year’s conference and why it matters:
Why is this event important for the data industry?
“Anytime you can meet outside of the screen is always a good thing. For me, it’s all about learning, networking, and inspiration. The world of data is expanding at an unprecedented pace. Global data volume is projected to reach over 180 zettabytes (or 180 trillion gigabytes) by 2025—tripling from just 64 zettabytes in 2020. That’s a massive jump. The question we need to ask is: What are modern organizations doing to not only secure all this data but also use it to unlock new business opportunities? That’s what I’m looking to explore at this summit.”
What topics do you think will be top-of-mind for attendees this year?
“I’m especially interested in the intersection of data engineering and AI. I’ve been lucky to work on modern data teams where we’ve adopted CI/CD pipelines and scalable architectures. AI has completely transformed how we manage data pipelines—mostly for the better. The conversation this year will likely revolve around how to continue that momentum while solving real-world challenges.”
Are there any sessions you’re particularly excited to attend?
“My plan is to soak in as many sessions on data and AI as possible. I’m especially curious about the use cases being shared, how organizations are applying these technologies today, and more importantly, how they plan to evolve them over the next few years.”
What makes this event special for you, personally?
“I’ve never been to this event before, but several of my peers have, and they spoke highly of the experience. Beyond the networking, I’m really looking forward to being inspired by the incredible work others are doing. As a speaker, I’m honored to be presenting on serverless engineering in today’s cloud-first world. I’m hoping to not only share insights but also get thoughtful feedback from the audience and my peers. Ultimately, I want to learn just as much from the people in the room as they might learn from me.”
What’s one thing you hope listeners take away from your presentation?
“My main takeaway is simple: start. If your data isn’t on the cloud yet, start that journey. If your engineering isn’t modernized, begin that process. Serverless is a key part of modern data engineering, but the real goal is enabling fast, informed decision-making through your data. It won’t always be easy—but it will be worth it.
I also hope that listeners understand the importance of composable data systems. If you’re building or working with data systems, composability gives you agility, scalability, and future-proofing. So instead of a big, all-in-one data platform (monolith), you get a flexible architecture where you can plug in best-in-class tools for each part of your data stack. Composable data systems let you choose the best tool for each job, swap out or upgrade parts without rewriting everything, and scale or customize workflows as your needs evolve.”
Don’t miss Perficient at Data Summit 2025. A global digital consultancy, Perficient is committed to partnering with clients to tackle complex business challenges and accelerate transformative growth.
]]>Isn’t SFO an airport? The airport one would travel if the destination is Oracle’s Redwood Shores campus. Widely known as the initialism for the San Francisco International Airport, the answer would be correct if this question were posed in that context. However, in Oracle Fusion, SFO stands for the Supply Chain Financial Orchestration. Based on what it does, we cannot call it an airport, but it sure is a control tower for financial transactions.
As companies are expanding their presence across countries and continents through mergers and acquisitions or natural growth, it becomes inevitable for the companies to transact across the borders and produce intercompany financial transactions.
Supply Chain Financial Orchestration (SFO), is the place where Oracle Fusion handles those transactions. The material may move one way, but for legal or financial reasons the financial flow could be following a different path.
A Typical Scenario
A Germany-based company sells to its EU customers from its Berlin office, but ships from its warehouses in New Delhi and Beijing.
Oracle Fusion SFO takes care of all those transactions and as transactions are processed in Cost Management, financial trade transactions are created, and corporations can see their internal margins, intercompany accounting, and intercompany invoices.
Oh wait, the financial orchestration doesn’t have to be across countries only. What if a corporation wants to measure its manufacturing and sales operations profitability? Supply Chain Financial Orchestration is there for you.
In short, SFO is a tool that is part of the Supply Chain management offering that helps create intercompany trade transactions for various business cases.
Contact Mehmet Erisen at Perficient for more introspection of this functionality, and how Perficient and Oracle Fusion Cloud can digitalize and modernize your ERP platform.
www.oracle.com
www.perficient.com
]]>Keeping up with today’s fast-paced technological environment, with businesses undergoing a significant transformation in operations, customer interactions, and innovation, can be challenging. Partnering with the right digital transformation service provider is essential for success. A proven track record in guiding businesses through digital complexities is crucial for unlocking their full potential, driving efficiency, and ensuring exceptional customer experiences, leading to long-term success.
The Digital Transformation Services Landscape, Q2 2025 Report
The recent Forrester report defines digital transformation services as – “Service providers that offer multidisciplinary capabilities to support enterprises in articulating, orchestrating, and governing strategy-aligned business transformation journeys, driving change across technology, ways of working, operating models, data, and corporate culture to continuously improve business outcomes.” This report provides an in-depth overview of 35 digital transformation service providers, offering valuable insights into the current market landscape.
Understanding the Providers
Forrester meticulously researched each service provider through a comprehensive set of questions. According to Forrester, “organizations leverage digital transformation services to:
- Articulate and orchestrate strategy-aligned transformation journeys.
- Align tech modernization with people, organization, and culture changes.
- Navigate transformation risks.”
Leaders can compare digital transformation service providers listed in the report based on size, offerings, geography, and business scenario differentiation to make informed decisions.
Core Business Scenarios
The report identifies the core business scenarios that are “most frequently sought after by buyers and addressed by digital transformation services solutions.” These scenarios include enterprise transformation, customer experience (CX) transformation, data and analytics transformation, and infrastructure and operational transformation.
Our Inclusion
We are proud to be listed in the Forrester Digital Transformation Services Landscape report as a digital transformation consultancy with an industry focus in the sectors of financial services, healthcare, and industrial products, and a geographic focus in four regions: North America (NA), Asia Pacific (APAC), and Latin America (LATAM).
As a dynamic global organization, we believe that with our cohesive, integrated strategy, we can deliver from any of our geographic locations and bring together the best team and the best value for the customer.
Access the Forrester report, The Digital Transformation Services Landscape, Q2 2025 to find out more.
Your Digital Transformation Journey
Seeing the world through your customers’ eyes is the best way to meet their needs. Our Digital Business Transformation practice enables leaders to meet the demands of today’s fast-changing, customer-centric world. We help you articulate a vision, formulate strategy, and align your team around the capabilities you need to stay ahead of disruption. Together, we resolve uncertainty, embrace change, and establish a North Star to guide your transformation journeys.
We implement the Envision Strategy Framework, a continuous and adaptive process that feeds real-world insights back into strategic decisions. This framework is informed by customer empathy and grounded in executional know-how. We put customers at the center of our digital strategy formulation process.
Supporting this is Envision Online, a comprehensive digital transformation platform that amplifies strategic decision-making based on the Envision Framework. With proprietary tools and a wealth of industry data, we deliver swift, actionable insights to help understand your organization’s competitive positioning.
Forrester does not endorse any company, product, brand, or service included in its research publications and does not advise any person to select the products or services of any company or brand based on the ratings included in such publications. Information is based on the best available resources. Opinions reflect judgment at the time and are subject to change. For more information, read about Forrester’s objectivity here .
]]>Generative AI (Gen AI) transforms how organizations interact with data and develop high-quality software. GenAI is a game changer in multiple industries, automating processes, increasing accuracy, and providing predictive insights. Here, we concentrate on its uses in data management, effects on efficiency, innovation, and cost savings.
GenAI in Data Management
Gen AI revolutionizes the data lifecycle by improving data quality, automating processes, and thus accelerating and improving decision-making. Key applications include:
- Data Augmentation: Gen AI generates synthetic data to augment existing datasets. This is more advantageous when training machine learning models that require diverse and large-scale data inputs.
- Data Cleansing finds and corrects duplicates, errors, missing values, and inconsistent formats, providing high-quality datasets ready for analysis.
- Data Enrichment: Gen AI generates fresh features for existing data (e.g., generating customer demographics based on purchase history or activity logs).
- Real-time Data Processing: Gen AI uses complex algorithms for real-time ingestion, cleansing, and transformations, guaranteeing seamless integration across systems.
- Predictive Analytics observes patterns and anomalies in data to forecast trends or spot a critical problem before it escalates.
Benefits of Data Management
- Accuracy and consistency of datasets are improved
- Operational costs and manual intervention are reduced.
- Improved innovation with high-quality data for better product development.
GenAI in Quality Assurance (QA)
GenAI is also transforming QA processes by automating test cases, generating test data, detecting bugs at an early stage, and performing predictive analysis. Its dynamic capabilities enhance the efficiency of software testing and reduce costs.
Applications in QA
Synthetic Test Data Generation: GenAI synthesizes realistic datasets critical for unbiased testing, assisting organizations with the ethical concerns of real-world data. It is especially relevant for healthcare.
Automated Test Case Generation: GenAI examines user stories and requirements using retrieval-augmented generation (RAG) and advanced algorithms to automatically create comprehensive test cases.
Exploration of Scenarios: QA teams can validate rare case scenarios that are difficult to find manually. GenAI is generating complexities that truly reflect realistic usages.
Continuous Monitoring: Unlike traditional AI approaches, GenAI monitors software performance in real-time even as development cycles run.
Test Automation: Generative AI enables tools like GitHub Copilot and AWS Code Whisperer to generate reusable code snippets to deploy automated tests, reducing manual work.
Benefits in QA
- Better, wider coverage of the test scenario and device.
- Predictive insights to identify defects faster.
- Saves Cost due to reduction of manual testing efforts.
Generative AI implementation challenges
As the advantages are considerable, there are some challenges to Gen AI implementation:
Integration Challenges: It may be challenging to ensure Compatibility with existing systems.
Data Sovereignty: Following regulations on how to handle sensitive or synthetic data e.g. GDPR compliance.
Resistant to Change: Individual teams might be unwilling to adjust to new tools because they either lack knowledge of how to utilize them or fear being displaced, not just by the tools themselves but also, in a wider sense, by automation.
Firm plans, stakeholder engagement, and clear guidance on AI tool use will help to ameliorate these challenges.
Conclusion
Generative AI is used to revolutionize data management and QA processes. Automating tasks to improve performance and accuracy for reducing errors and predictive analytics via synthetic data creation is a way to distinguish oneself as the foundation of certain emerging digital transformation strategies today. The more businesses collaborate with GenAI throughout their workflows, the more its capabilities will reveal efficiency and innovation, at blazing speed.
]]>AI is a paradigm-changing technology, fundamentally transforming the way we work, live, and interact with technology and the world at large. From healthcare to finance, AI is revolutionizing industries with process automation, increasing efficacy, and innovation. However, these AI advancements come with ethical risks, which is still a matter we need to solve, and the ethical impact of AI needs to be addressed urgently, as it becomes more and more embedded within our society. The implementation of AI in an unethical position is not just a technical challenge but rather a moral obligation.
What is AI Ethics?
AI ethics refers to the principles and practices that guide the responsible development and use of AI technology that it is beneficial to society and minimizes potential harm. Ethical AI focuses on:
Fairness: Avoiding resources that could presumably be discriminative.
Transparency: Ensuring AI decision-making processes are understandable.
Accountability: Encouraging developers and organizations to be accountable for the impacts of AI.
Privacy: Better protection of user’s data from misuse.
Environmental Impact: Greener AI tech, carbon footprint.
Why Ethics in AI Matter
AI systems are being built into critical areas such as healthcare, the criminal justice system, hiring, and finance. Disconnected from ethics, these systems can reproduce socio-cultural biases and make decisions that are non-intuitive to humans or have harmful consequences to people. For instance:
- Amazon eliminated an AI recruiting tool because the data used to train its models was biased, favoring men over women.
- The Netherlands childcare benefits scandal showed how biased algorithms can ruin lives with false allegations of fraud.
These examples illustrate the potential for harm when ethical frameworks are neglected.
Key Ethical Challenges in AI
Bias and Discrimination
Artificial intelligence systems often have biases that mirror the inclinations of the data used for their training. If left unchecked, these inclinations can lead to injustice towards specific groups.
Transparency
Many AI models are “black boxes,” and it’s hard to tell how or why they make a decision. Lack of transparency undermines trust, especially when decisions are based on unclear or unreliable data.
Accountability
Determining responsibility for an AI system’s actions, especially in high-stakes scenarios like healthcare, remains a complex issue.
Privacy Concerns
AI systems are collecting and using personal data very quickly and on a large scale, that raises serious questions of privacy. Especially given that there is little accountability and transparency around how data is being used, and users have almost zero knowledge of what those systems will do with that data.
Environmental Impact
Training large-scale machine learning models has an energy cost that is substantially high and degrades the environment.
Strategies for Implementing Ethical and Efficient AI
Implementation
Organizations should proactively implement ethical practices at all levels of their AI framework:
1. Create Ethical Guidelines for Internal Use
- Develop policies, mitigate bias, promote transparency, accountability, and privacy.
- Create an AI Ethics Committee to monitor compliance with these guidelines.
2. Diversity in Data and Teams
- Use diverse data sets which cover a wide range of demographics.
-
Having teams that are diverse in background will help to see ethical blind spots.
3. Embed Ethics into Development
- Considering ethical implications at each stage of AI development.
- Regularly auditing datasets and algorithms for biases.
4. Continuous Monitoring
- Using checklists to review and apply ethical guidelines.
- Engaging third-party audits to provide unbiased perspectives on system functioning.
5. Educate Stakeholders
- Training programs to educate employees on ethical ideas and good practices in using AI.
- Including cross-functional conversations among developers, legal teams, and user advocates.
6. Partner with Ethical Partners
- Build partnership with suppliers committed to ethical AI solutions.
- Seeking transparency, clarity, fairness, and accountability in external tools and evaluating them before implementation.
Forging the Future
Indeed, an ethically responsible approach to AI is both a technical challenge and a societal imperative. By emphasizing fairness, transparency, accountability, and privacy protection, organizations can develop systems that are both trustworthy and aligned with human values. As the forces shaping the future continue to evolve, our responsibility to ensure inclusive and ethical innovation must grow alongside them.
AI ethics is a shared responsibility involving developers, businesses, policymakers, and society at large. By taking deliberate steps toward responsible implementation today, we can shape a future where AI enhances lives without compromising fundamental rights or values.
]]>
This guide will walk you through building a small application step-by-step, focusing on integrating several powerful tools and concepts essential for modern Android development.
What We’ll Cover:
- Jetpack Compose: Building the UI declaratively.
- NoSQL Database (Firestore): Storing and retrieving data in the cloud.
- WorkManager: Running reliable background tasks.
- Build Flavors: Creating different versions of the app (e.g., dev vs. prod).
- Proguard/R8: Shrinking and obfuscating your code for release.
- Firebase App Distribution: Distributing test builds easily.
- CI/CD (GitHub Actions): Automating the build and distribution process.
The Goal: Build a “Task Reporter” app. Users can add simple task descriptions. These tasks are saved to Firestore. A background worker will periodically “report” (log a message or update a counter in Firestore) that the app is active. We’ll have dev and prod flavors pointing to different Firestore collections/data and distribute the dev build for testing.
Prerequisites:
- Android Studio (latest stable version recommended).
- Basic understanding of Kotlin and Android development fundamentals.
- Familiarity with Jetpack Compose basics (Composable functions, State).
- A Google account to use Firebase.
- A GitHub account (for CI/CD).
Let’s get started!
Step 0: Project Setup
- Create New Project: Open Android Studio -> New Project -> Empty Activity (choose Compose).
- Name:
AdvancedConceptsApp(or your choice). - Package Name: Your preferred package name (e.g.,
com.yourcompany.advancedconceptsapp). - Language: Kotlin.
- Minimum SDK: API 24 or higher.
- Build Configuration Language: Kotlin DSL (
build.gradle.kts). - Click Finish.
Step 1: Firebase Integration (Firestore & App Distribution)
- Connect to Firebase: In Android Studio: Tools -> Firebase.
- In the Assistant panel, find Firestore. Click “Get Started with Cloud Firestore”. Click “Connect to Firebase”. Follow the prompts to create a new Firebase project or connect to an existing one.
- Click “Add Cloud Firestore to your app”. Accept changes to your
build.gradle.kts(orbuild.gradle) files. This adds the necessary dependencies. - Go back to the Firebase Assistant, find App Distribution. Click “Get Started”. Add the App Distribution Gradle plugin by clicking the button. Accept changes.
- Enable Services in Firebase Console:
- Go to the Firebase Console and select your project.
- Enable Firestore Database (start in Test mode).
- In the left menu, go to Build -> Firestore Database. Click “Create database”.
- Start in Test mode for easier initial development (we’ll secure it later if needed). Choose a location close to your users. Click “Enable”.
- Ensure App Distribution is accessible (no setup needed here yet).
- Download Initial
google-services.json:- In Firebase Console -> Project Settings (gear icon) -> Your apps.
- Ensure your Android app (using the base package name like
com.yourcompany.advancedconceptsapp) is registered. If not, add it. - Download the
google-services.jsonfile. - Switch Android Studio to the Project view and place the file inside the
app/directory. - Note: We will likely replace this file in Step 4 after configuring build flavors.
Step 2: Building the Basic UI with Compose
Let’s create a simple UI to add and display tasks.
- Dependencies: Ensure necessary dependencies for Compose, ViewModel, Firestore, and WorkManager are in
app/build.gradle.kts.
app/build.gradle.ktsdependencies { // Core & Lifecycle & Activity implementation("androidx.core:core-ktx:1.13.1") // Use latest versions implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.1") implementation("androidx.activity:activity-compose:1.9.0") // Compose implementation(platform("androidx.compose:compose-bom:2024.04.01")) // Check latest BOM implementation("androidx.compose.ui:ui") implementation("androidx.compose.ui:ui-graphics") implementation("androidx.compose.ui:ui-tooling-preview") implementation("androidx.compose.material3:material3") implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.8.1") // Firebase implementation(platform("com.google.firebase:firebase-bom:33.0.0")) // Check latest BOM implementation("com.google.firebase:firebase-firestore-ktx") // WorkManager implementation("androidx.work:work-runtime-ktx:2.9.0") // Check latest version }Sync Gradle files.
- Task Data Class: Create
data/Task.kt.
data/Task.ktpackage com.yourcompany.advancedconceptsapp.data import com.google.firebase.firestore.DocumentId data class Task( @DocumentId val id: String = "", val description: String = "", val timestamp: Long = System.currentTimeMillis() ) { constructor() : this("", "", 0L) // Firestore requires a no-arg constructor } - ViewModel: Create
ui/TaskViewModel.kt. (We’ll update the collection name later).
ui/TaskViewModel.ktpackage com.yourcompany.advancedconceptsapp.ui import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope import com.google.firebase.firestore.ktx.firestore import com.google.firebase.firestore.ktx.toObjects import com.google.firebase.ktx.Firebase import com.yourcompany.advancedconceptsapp.data.Task // Import BuildConfig later when needed import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.launch import kotlinx.coroutines.tasks.await // Temporary placeholder - will be replaced by BuildConfig field const val TEMPORARY_TASKS_COLLECTION = "tasks" class TaskViewModel : ViewModel() { private val db = Firebase.firestore // Use temporary constant for now private val tasksCollection = db.collection(TEMPORARY_TASKS_COLLECTION) private val _tasks = MutableStateFlow<List<Task>>(emptyList()) val tasks: StateFlow<List<Task>> = _tasks private val _error = MutableStateFlow<String?>(null) val error: StateFlow<String?> = _error init { loadTasks() } fun loadTasks() { viewModelScope.launch { try { tasksCollection.orderBy("timestamp", com.google.firebase.firestore.Query.Direction.DESCENDING) .addSnapshotListener { snapshots, e -> if (e != null) { _error.value = "Error listening: ${e.localizedMessage}" return@addSnapshotListener } _tasks.value = snapshots?.toObjects<Task>() ?: emptyList() _error.value = null } } catch (e: Exception) { _error.value = "Error loading: ${e.localizedMessage}" } } } fun addTask(description: String) { if (description.isBlank()) { _error.value = "Task description cannot be empty." return } viewModelScope.launch { try { val task = Task(description = description, timestamp = System.currentTimeMillis()) tasksCollection.add(task).await() _error.value = null } catch (e: Exception) { _error.value = "Error adding: ${e.localizedMessage}" } } } } - Main Screen Composable: Create
ui/TaskScreen.kt.
ui/TaskScreen.ktpackage com.yourcompany.advancedconceptsapp.ui // Imports: androidx.compose.*, androidx.lifecycle.viewmodel.compose.viewModel, java.text.SimpleDateFormat, etc. import androidx.compose.foundation.layout.* import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items import androidx.compose.material3.* import androidx.compose.runtime.* import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.unit.dp import androidx.lifecycle.viewmodel.compose.viewModel import com.yourcompany.advancedconceptsapp.data.Task import java.text.SimpleDateFormat import java.util.Date import java.util.Locale import androidx.compose.ui.res.stringResource import com.yourcompany.advancedconceptsapp.R // Import R class @OptIn(ExperimentalMaterial3Api::class) // For TopAppBar @Composable fun TaskScreen(taskViewModel: TaskViewModel = viewModel()) { val tasks by taskViewModel.tasks.collectAsState() val errorMessage by taskViewModel.error.collectAsState() var taskDescription by remember { mutableStateOf("") } Scaffold( topBar = { TopAppBar(title = { Text(stringResource(id = R.string.app_name)) }) // Use resource for flavor changes } ) { paddingValues -> Column(modifier = Modifier.padding(paddingValues).padding(16.dp).fillMaxSize()) { // Input Row Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { OutlinedTextField( value = taskDescription, onValueChange = { taskDescription = it }, label = { Text("New Task Description") }, modifier = Modifier.weight(1f), singleLine = true ) Spacer(modifier = Modifier.width(8.dp)) Button(onClick = { taskViewModel.addTask(taskDescription) taskDescription = "" }) { Text("Add") } } Spacer(modifier = Modifier.height(16.dp)) // Error Message errorMessage?.let { Text(it, color = MaterialTheme.colorScheme.error, modifier = Modifier.padding(bottom = 8.dp)) } // Task List if (tasks.isEmpty() && errorMessage == null) { Text("No tasks yet. Add one!") } else { LazyColumn(modifier = Modifier.weight(1f)) { items(tasks, key = { it.id }) { task -> TaskItem(task) Divider() } } } } } } @Composable fun TaskItem(task: Task) { val dateFormat = remember { SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.getDefault()) } Row(modifier = Modifier.fillMaxWidth().padding(vertical = 8.dp), verticalAlignment = Alignment.CenterVertically) { Column(modifier = Modifier.weight(1f)) { Text(task.description, style = MaterialTheme.typography.bodyLarge) Text("Added: ${dateFormat.format(Date(task.timestamp))}", style = MaterialTheme.typography.bodySmall) } } } - Update
MainActivity.kt: Set the content toTaskScreen.
MainActivity.ktpackage com.yourcompany.advancedconceptsapp import android.os.Bundle import androidx.activity.ComponentActivity import androidx.activity.compose.setContent import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Surface import androidx.compose.ui.Modifier import com.yourcompany.advancedconceptsapp.ui.TaskScreen import com.yourcompany.advancedconceptsapp.ui.theme.AdvancedConceptsAppTheme // Imports for WorkManager scheduling will be added in Step 3 class MainActivity : ComponentActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContent { AdvancedConceptsAppTheme { Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) { TaskScreen() } } } // TODO: Schedule WorkManager job in Step 3 } } - Run the App: Test basic functionality. Tasks should appear and persist in Firestore’s `tasks` collection (initially).
Step 3: WorkManager Implementation
Create a background worker for periodic reporting.
- Create the Worker: Create
worker/ReportingWorker.kt. (Collection name will be updated later).
worker/ReportingWorker.ktpackage com.yourcompany.advancedconceptsapp.worker import android.content.Context import android.util.Log import androidx.work.CoroutineWorker import androidx.work.WorkerParameters import com.google.firebase.firestore.ktx.firestore import com.google.firebase.ktx.Firebase // Import BuildConfig later when needed import kotlinx.coroutines.tasks.await // Temporary placeholder - will be replaced by BuildConfig field const val TEMPORARY_USAGE_LOG_COLLECTION = "usage_logs" class ReportingWorker(appContext: Context, workerParams: WorkerParameters) : CoroutineWorker(appContext, workerParams) { companion object { const val TAG = "ReportingWorker" } private val db = Firebase.firestore override suspend fun doWork(): Result { Log.d(TAG, "Worker started: Reporting usage.") return try { val logEntry = hashMapOf( "timestamp" to System.currentTimeMillis(), "message" to "App usage report.", "worker_run_id" to id.toString() ) // Use temporary constant for now db.collection(TEMPORARY_USAGE_LOG_COLLECTION).add(logEntry).await() Log.d(TAG, "Worker finished successfully.") Result.success() } catch (e: Exception) { Log.e(TAG, "Worker failed", e) Result.failure() } } } - Schedule the Worker: Update
MainActivity.kt‘sonCreatemethod.
MainActivity.kt additions// Add these imports to MainActivity.kt import android.content.Context import android.util.Log import androidx.work.* import com.yourcompany.advancedconceptsapp.worker.ReportingWorker import java.util.concurrent.TimeUnit // Inside MainActivity class, after setContent { ... } block in onCreate override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContent { // ... existing code ... } // Schedule the worker schedulePeriodicUsageReport(this) } // Add this function to MainActivity class private fun schedulePeriodicUsageReport(context: Context) { val constraints = Constraints.Builder() .setRequiredNetworkType(NetworkType.CONNECTED) .build() val reportingWorkRequest = PeriodicWorkRequestBuilder<ReportingWorker>( 1, TimeUnit.HOURS // ~ every hour ) .setConstraints(constraints) .addTag(ReportingWorker.TAG) .build() WorkManager.getInstance(context).enqueueUniquePeriodicWork( ReportingWorker.TAG, ExistingPeriodicWorkPolicy.KEEP, reportingWorkRequest ) Log.d("MainActivity", "Periodic reporting work scheduled.") } - Test WorkManager:
- Run the app. Check Logcat for messages from
ReportingWorkerandMainActivityabout scheduling. - WorkManager tasks don’t run immediately, especially periodic ones. You can use ADB commands to force execution for testing:
- Find your package name:
com.yourcompany.advancedconceptsapp - Force run jobs:
adb shell cmd jobscheduler run -f com.yourcompany.advancedconceptsapp 999(The 999 is usually sufficient, it’s a job ID). - Or use Android Studio’s App Inspection tab -> Background Task Inspector to view and trigger workers.
- Find your package name:
- Check your Firestore Console for the
usage_logscollection.
- Run the app. Check Logcat for messages from
Step 4: Build Flavors (dev vs. prod)
Create dev and prod flavors for different environments.
- Configure
app/build.gradle.kts:
app/build.gradle.ktsandroid { // ... namespace, compileSdk, defaultConfig ... // ****** Enable BuildConfig generation ****** buildFeatures { buildConfig = true } // ******************************************* flavorDimensions += "environment" productFlavors { create("dev") { dimension = "environment" applicationIdSuffix = ".dev" // CRITICAL: Changes package name for dev builds versionNameSuffix = "-dev" resValue("string", "app_name", "Task Reporter (Dev)") buildConfigField("String", "TASKS_COLLECTION", "\"tasks_dev\"") buildConfigField("String", "USAGE_LOG_COLLECTION", "\"usage_logs_dev\"") } create("prod") { dimension = "environment" resValue("string", "app_name", "Task Reporter") buildConfigField("String", "TASKS_COLLECTION", "\"tasks\"") buildConfigField("String", "USAGE_LOG_COLLECTION", "\"usage_logs\"") } } // ... buildTypes, compileOptions, etc ... }Sync Gradle files.
Important: We addedapplicationIdSuffix = ".dev". This means the actual package name for your development builds will become something likecom.yourcompany.advancedconceptsapp.dev. This requires an update to your Firebase project setup, explained next. Also note thebuildFeatures { buildConfig = true }block which is required to usebuildConfigField. -
Handling Firebase for Suffixed Application IDs
Because the `dev` flavor now has a different application ID (`…advancedconceptsapp.dev`), the original `google-services.json` file (downloaded in Step 1) will not work for `dev` builds, causing a “No matching client found” error during build.
You must add this new Application ID to your Firebase project:
- Go to Firebase Console: Open your project settings (gear icon).
- Your apps: Scroll down to the “Your apps” card.
- Add app: Click “Add app” and select the Android icon (</>).
- Register dev app:
- Package name: Enter the exact suffixed ID:
com.yourcompany.advancedconceptsapp.dev(replace `com.yourcompany.advancedconceptsapp` with your actual base package name). - Nickname (Optional): “Task Reporter Dev”.
- SHA-1 (Optional but Recommended): Add the debug SHA-1 key from `./gradlew signingReport`.
- Package name: Enter the exact suffixed ID:
- Register and Download: Click “Register app”. Crucially, download the new
google-services.jsonfile offered. This file now contains configurations for BOTH your base ID and the `.dev` suffixed ID. - Replace File: In Android Studio (Project view), delete the old
google-services.jsonfrom theapp/directory and replace it with the **newly downloaded** one. - Skip SDK steps: You can skip the remaining steps in the Firebase console for adding the SDK.
- Clean & Rebuild: Back in Android Studio, perform a Build -> Clean Project and then Build -> Rebuild Project.
Now your project is correctly configured in Firebase for both `dev` (with the `.dev` suffix) and `prod` (base package name) variants using a single `google-services.json`. - Create Flavor-Specific Source Sets:
- Switch to Project view in Android Studio.
- Right-click on
app/src-> New -> Directory. Name itdev. - Inside
dev, createres/values/directories. - Right-click on
app/src-> New -> Directory. Name itprod. - Inside
prod, createres/values/directories. - (Optional but good practice): You can now move the default
app_namestring definition fromapp/src/main/res/values/strings.xmlinto bothapp/src/dev/res/values/strings.xmlandapp/src/prod/res/values/strings.xml. Or, you can rely solely on theresValuedefinitions in Gradle (as done above). UsingresValueis often simpler for single strings likeapp_name. If you had many different resources (layouts, drawables), you’d put them in the respectivedev/resorprod/resfolders.
- Use Build Config Fields in Code:
-
- Update
TaskViewModel.ktandReportingWorker.ktto useBuildConfiginstead of temporary constants.
- Update
TaskViewModel.kt change
// Add this import import com.yourcompany.advancedconceptsapp.BuildConfig // Replace the temporary constant usage // const val TEMPORARY_TASKS_COLLECTION = "tasks" // Remove this line private val tasksCollection = db.collection(BuildConfig.TASKS_COLLECTION) // Use build config fieldReportingWorker.kt change
// Add this import import com.yourcompany.advancedconceptsapp.BuildConfig // Replace the temporary constant usage // const val TEMPORARY_USAGE_LOG_COLLECTION = "usage_logs" // Remove this line // ... inside doWork() ... db.collection(BuildConfig.USAGE_LOG_COLLECTION).add(logEntry).await() // Use build config fieldModify
TaskScreen.ktto potentially use the flavor-specific app name (thoughresValuehandles this automatically if you referenced@string/app_namecorrectly, whichTopAppBarusually does). If you set the title directly, you would load it from resources:// In TaskScreen.kt (if needed)
import androidx.compose.ui.res.stringResource
import com.yourcompany.advancedconceptsapp.R // Import R class
// Inside Scaffold -> topBar
TopAppBar(title = { Text(stringResource(id = R.string.app_name)) }) // Use string resource -
- Select Build Variant & Test:
- In Android Studio, go to Build -> Select Build Variant… (or use the “Build Variants” panel usually docked on the left).
- You can now choose between
devDebug,devRelease,prodDebug, andprodRelease. - Select
devDebug. Run the app. The title should say “Task Reporter (Dev)”. Data should go totasks_devandusage_logs_devin Firestore. - Select
prodDebug. Run the app. The title should be “Task Reporter”. Data should go totasksandusage_logs.
Step 5: Proguard/R8 Configuration (for Release Builds)
R8 is the default code shrinker and obfuscator in Android Studio (successor to Proguard). It’s enabled by default for release build types. We need to ensure it doesn’t break our app, especially Firestore data mapping.
-
- Review
app/build.gradle.ktsRelease Build Type:
app/build.gradle.ktsandroid { // ... buildTypes { release { isMinifyEnabled = true // Should be true by default for release isShrinkResources = true // R8 handles both proguardFiles( getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro" // Our custom rules file ) } debug { isMinifyEnabled = false // Usually false for debug proguardFiles( getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro" ) } // ... debug build type ... } // ... }isMinifyEnabled = trueenables R8 for thereleasebuild type. - Configure
app/proguard-rules.pro:- Firestore uses reflection to serialize/deserialize data classes. R8 might remove or rename classes/fields needed for this process. We need to add “keep” rules.
- Open (or create) the
app/proguard-rules.profile. Add the following:
# Keep Task data class and its members for Firestore serialization -keep class com.yourcompany.advancedconceptsapp.data.Task { (...); *; } # Keep any other data classes used with Firestore similarly # -keep class com.yourcompany.advancedconceptsapp.data.AnotherFirestoreModel { (...); *; } # Keep Coroutine builders and intrinsics (often needed, though AGP/R8 handle some automatically) -keepnames class kotlinx.coroutines.intrinsics.** { *; } # Keep companion objects for Workers if needed (sometimes R8 removes them) -keepclassmembers class * extends androidx.work.Worker { public static ** Companion; } # Keep specific fields/methods if using reflection elsewhere # -keepclassmembers class com.example.SomeClass { # private java.lang.String someField; # public void someMethod(); # } # Add rules for any other libraries that require them (e.g., Retrofit, Gson, etc.) # Consult library documentation for necessary Proguard/R8 rules.
- Review
-
- Explanation:
-keep class ... { <init>(...); *; }: Keeps theTaskclass, its constructors (<init>), and all its fields/methods (*) from being removed or renamed. This is crucial for Firestore.-keepnames: Prevents renaming but allows removal if unused.-keepclassmembers: Keeps specific members within a class.
- Explanation:
3. Test the Release Build:
-
- Select the
prodReleasebuild variant. - Go to Build -> Generate Signed Bundle / APK…. Choose APK.
- Create a new keystore or use an existing one (follow the prompts). Remember the passwords!
- Select
prodReleaseas the variant. Click Finish. - Android Studio will build the release APK. Find it (usually in
app/prod/release/). - Install this APK manually on a device:
adb install app-prod-release.apk. - Test thoroughly. Can you add tasks? Do they appear? Does the background worker still log to Firestore (check
usage_logs)? If it crashes or data doesn’t save/load correctly, R8 likely removed something important. Check Logcat for errors (oftenClassNotFoundExceptionorNoSuchMethodError) and adjust yourproguard-rules.profile accordingly.
- Select the
Step 6: Firebase App Distribution (for Dev Builds)
Configure Gradle to upload development builds to testers via Firebase App Distribution.
- Download private key: on Firebase console go to Project Overview at left top corner -> Service accounts -> Firebase Admin SDK -> Click on “Generate new private key” button ->
api-project-xxx-yyy.jsonmove this file to root project at the same level of app folder *Ensure that this file be in your local app, do not push it to the remote repository because it contains sensible data and will be rejected later - Configure App Distribution Plugin in
app/build.gradle.kts:
app/build.gradle.kts// Apply the plugin at the top plugins { // ... other plugins id("com.android.application"), id("kotlin-android"), etc. alias(libs.plugins.google.firebase.appdistribution) } android { // ... buildFeatures, flavorDimensions, productFlavors ... buildTypes { getByName("release") { isMinifyEnabled = true // Should be true by default for release isShrinkResources = true // R8 handles both proguardFiles( getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro" // Our custom rules file ) } getByName("debug") { isMinifyEnabled = false // Usually false for debug proguardFiles( getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro" ) } firebaseAppDistribution { artifactType = "APK" releaseNotes = "Latest build with fixes/features" testers = "briew@example.com, bri@example.com, cal@example.com" serviceCredentialsFile="$rootDir/api-project-xxx-yyy.json"//do not push this line to the remote repository or stablish as local variable } } }Add library version to libs.version.toml
[versions] googleFirebaseAppdistribution = "5.1.1" [plugins] google-firebase-appdistribution = { id = "com.google.firebase.appdistribution", version.ref = "googleFirebaseAppdistribution" } Ensure the plugin classpath is in theproject-level
build.gradle.kts:project build.gradle.kts
plugins { // ... alias(libs.plugins.google.firebase.appdistribution) apply false }Sync Gradle files.
- Upload a Build Manually:
- Select the desired variant (e.g.,
devDebug,devRelease,prodDebug,prodRelease). - In Android Studio Terminal run each commmand to generate apk version for each environment:
./gradlew assembleRelease appDistributionUploadProdRelease./gradlew assembleRelease appDistributionUploadDevRelease./gradlew assembleDebug appDistributionUploadProdDebug./gradlew assembleDebug appDistributionUploadDevDebug
- Check Firebase Console -> App Distribution -> Select .dev project . Add testers or use the configured group (`android-testers`).
- Select the desired variant (e.g.,
Step 7: CI/CD with GitHub Actions
Automate building and distributing the `dev` build on push to a specific branch.
- Create GitHub Repository. Create a new repository on GitHub and push your project code to it.
-
- Generate FIREBASE_APP_ID:
- on Firebase App Distribution go to Project Overview -> General -> App ID for com.yourcompany.advancedconceptsapp.dev environment (1:xxxxxxxxx:android:yyyyyyyyyy)
- In GitHub repository go to Settings -> Secrets and variables -> Actions -> New repository secret
- Set the name: FIREBASE_APP_ID and value: paste the App ID generated
- Add FIREBASE_SERVICE_ACCOUNT_KEY_JSON:
- open
api-project-xxx-yyy.jsonlocated at root project and copy the content - In GitHub repository go to Settings -> Secrets and variables -> Actions -> New repository secret
- Set the name: FIREBASE_SERVICE_ACCOUNT_KEY_JSON and value: paste the json content
- open
- Create GitHub Actions Workflow File:
- In your project root, create the directories
.github/workflows/. - Inside
.github/workflows/, create a new file namedandroid_build_distribute.yml. - Paste the following content:
- In your project root, create the directories
-
name: Android CI on: push: branches: [ "main" ] pull_request: branches: [ "main" ] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: set up JDK 17 uses: actions/setup-java@v3 with: java-version: '17' distribution: 'temurin' cache: gradle - name: Grant execute permission for gradlew run: chmod +x ./gradlew - name: Build devRelease APK run: ./gradlew assembleRelease - name: upload artifact to Firebase App Distribution uses: wzieba/Firebase-Distribution-Github-Action@v1 with: appId: ${{ secrets.FIREBASE_APP_ID }} serviceCredentialsFileContent: ${{ secrets.FIREBASE_SERVICE_ACCOUNT_KEY_JSON }} groups: testers file: app/build/outputs/apk/dev/release/app-dev-release-unsigned.apk
- Generate FIREBASE_APP_ID:
-
- Commit and Push: Commit the
.github/workflows/android_build_distribute.ymlfile and push it to yourmainbranch on GitHub.
- Commit and Push: Commit the
-
- Verify: Go to the “Actions” tab in your GitHub repository. You should see the workflow running. If it succeeds, check Firebase App Distribution for the new build. Your testers should get notified.
Step 8: Testing and Verification Summary
-
- Flavors: Switch between
devDebugandprodDebugin Android Studio. Verify the app name changes and data goes to the correct Firestore collections (tasks_dev/tasks,usage_logs_dev/usage_logs).
- Flavors: Switch between
-
- WorkManager: Use the App Inspection -> Background Task Inspector or ADB commands to verify the
ReportingWorkerruns periodically and logs data to the correct Firestore collection based on the selected flavor.
- WorkManager: Use the App Inspection -> Background Task Inspector or ADB commands to verify the
-
- R8/Proguard: Install and test the
prodReleaseAPK manually. Ensure all features work, especially adding/viewing tasks (Firestore interaction). Check Logcat for crashes related to missing classes/methods.
- R8/Proguard: Install and test the
-
- App Distribution: Make sure testers receive invites for the
devDebug(ordevRelease) builds uploaded manually or via CI/CD. Ensure they can install and run the app.
- App Distribution: Make sure testers receive invites for the
-
- CI/CD: Check the GitHub Actions logs for successful builds and uploads after pushing to the
developbranch. Verify the build appears in Firebase App Distribution.
- CI/CD: Check the GitHub Actions logs for successful builds and uploads after pushing to the
Conclusion
Congratulations! You’ve navigated complex Android topics including Firestore, WorkManager, Compose, Flavors (with correct Firebase setup), R8, App Distribution, and CI/CD.
This project provides a solid foundation. From here, you can explore:
-
- More complex WorkManager chains or constraints.
-
- Deeper R8/Proguard rule optimization.
-
- More sophisticated CI/CD pipelines (deploy signed apks/bundles, running tests, deploying to Google Play).
-
- Using different NoSQL databases or local caching with Room.
-
- Advanced Compose UI patterns and state management.
-
- Firebase Authentication, Cloud Functions, etc.
If you want to have access to the full code in my GitHub repository, contact me in the comments.
Project Folder Structure (Conceptual)
AdvancedConceptsApp/
├── .git/
├── .github/workflows/android_build_distribute.yml
├── .gradle/
├── app/
│ ├── build/
│ ├── libs/
│ ├── src/
│ │ ├── main/ # Common code, res, AndroidManifest.xml
│ │ │ └── java/com/yourcompany/advancedconceptsapp/
│ │ │ ├── data/Task.kt
│ │ │ ├── ui/TaskScreen.kt, TaskViewModel.kt, theme/
│ │ │ ├── worker/ReportingWorker.kt
│ │ │ └── MainActivity.kt
│ │ ├── dev/ # Dev flavor source set (optional overrides)
│ │ ├── prod/ # Prod flavor source set (optional overrides)
│ │ ├── test/ # Unit tests
│ │ └── androidTest/ # Instrumentation tests
│ ├── google-services.json # *** IMPORTANT: Contains configs for BOTH package names ***
│ ├── build.gradle.kts # App-level build script
│ └── proguard-rules.pro # R8/Proguard rules
├── api-project-xxx-yyy.json # Firebase service account key json
├── gradle/wrapper/
├── build.gradle.kts # Project-level build script
├── gradle.properties
├── gradlew
├── gradlew.bat
└── settings.gradle.kts
]]>
A ticketing system, such as a Dynamic Tracking Tool, can be a powerful tool for MSO support teams, providing a centralized and efficient way to manage incidents and service requests. Here are some more details on the benefits.
- Organize and triage cases: With a ticketing system, MSO support teams can easily prioritize cases based on their priority, status, and other relevant information. This allows them to quickly identify and resolve critical issues before they become major problems.
- Automate distribution and assignment: A ticketing system can automate the distribution and assignment of incidents to the right department staff member. This ensures that incidents are quickly and efficiently handled by the most qualified support team members.
- Increase collaboration: A ticketing system can increase collaboration between customer service teams and other stakeholders. It allows for easy and quick ticket assignment, collaboration in resolving issues, and real-time changes.
- Consolidate support needs: Using a ticketing system consolidates all support needs in one place, providing a record of customer interactions stored in the system. This allows support teams to quickly and easily access customer history, track communication, and resolve issues more effectively.
- Dynamics Tracking Tool: This shows various reports, such as the Real-Time Tracking Report and Historical Data Report, which are provided to monitor and analyze tracking data efficiently.
Overall, a ticketing system can help MSO support teams to be more organized, efficient, and effective in managing incidents and service requests.
Benefits of a Dynamic Ticketing Management System
- Prioritization: A ticketing system efficiently prioritizes incidents based on their impact on the business and their urgency. This ensures critical issues are resolved quickly, minimizing downtime and maximizing productivity.
- Efficiency: A ticketing system streamlines the incident management process, reducing the time and effort required to handle incidents. It allows support teams to focus on resolving issues rather than spending time on administrative tasks such as logging incidents and updating users.
- Collaboration: A ticketing system enables collaboration between support teams, allowing them to share information and expertise to resolve incidents more efficiently. It also enables users to collaborate with support teams, providing real-time updates and feedback on the status of their incidents.
- Tracking & Reporting: A ticketing system provides detailed monitoring and reporting capabilities, allowing businesses to analyze incident data and identify trends and patterns. This information can be used to identify recurring issues, develop strategies to prevent incidents from occurring, and improve the overall quality of support services.
- Professionalism: A ticketing system provides a professional and consistent approach to incident management, ensuring that all incidents are handled promptly and efficiently. This helps to enhance the reputation of the support team and the business as a whole.
- Transparency: A ticketing system provides transparency in the incident management process, allowing users to track the status of their incidents in real time. It also provides visibility into the actions taken by support teams, enabling users to understand how incidents are being resolved.
- Continuity: A ticketing system provides continuity in the incident management process, ensuring that incidents are handled consistently and effectively across the organization. It also ensures that incident data is captured and stored in a centralized location, providing a comprehensive view of the incident management process.
A Support System Orbits Around 3-Tiered Support
Tier 1
Tier 1 tech support is typically the first level of technical support in a multi-tiered technical support model. It is responsible for handling basic customer issues and providing initial diagnosis and resolution of technical problems.
A Tier 1 specialist’s primary responsibility is to gather customer information and analyze the symptoms to determine the underlying problem. They may use pre-determined scripts or workflows to troubleshoot common technical issues and provide basic solutions.
If the issue is beyond their expertise, they may escalate it to the appropriate Tier 2 or Tier 3 support team for further investigation and resolution.
Overall, Tier 1 tech support is critical for providing initial assistance to customers and ensuring that technical issues are addressed promptly and efficiently.
Tier 2
Tier 2 support is the second level of technical support in a multi-tiered technical support model, and it typically involves more specialized technical knowledge and skills than Tier 2 support.
Tier 2 support is staffed by technicians with in-depth technical knowledge and experience troubleshooting complex technical issues. These technicians are responsible for providing more advanced technical assistance to customers, and they may use more specialized tools or equipment to diagnose and resolve technical problems.
Tier 2 support is critical for resolving complex technical issues and ensuring that customers receive high-quality technical assistance.
Tier 3
Support typically involves highly specialized technical knowledge and skills, and technicians at this level are often subject matter experts in their respective areas. They may be responsible for developing new solutions or workarounds for complex technical issues and providing training and guidance to Tier 1 and Tier 2 support teams.
In some cases, Tier 3 support may be provided by the product or service vendor, while in other cases, it may be provided by a third-party provider. The goal of Tier 3 support is to ensure that the most complex technical issues are resolved as quickly and efficiently as possible, minimizing downtime and ensuring customer satisfaction.
Overall, Tier 3 support is critical in providing advanced technical assistance and ensuring that the most complex technical problems are resolved effectively.
Determine The Importance of Tickets/Incidents/Issues/Cases
The first step in a support ticketing system is to determine the incident’s importance. This involves assessing the incident’s impact on the user and the business and assigning a priority level based on the severity of the issue.
- Receiving: The step is to receive the incident report from the user. This can be done through various channels, such as email, phone, or a web-based form.
- Validating: This step involves validating the incident and verifying that it is a valid issue that needs to be addressed by the Support team.
- Logging: Once the incident has been validated, it is logged into an incident application, which is used to track and manage it throughout the process.
- Screening: The next step is to screen the incident and determine the user’s symptoms. This involves asking questions to gather more information about the issue and to identify any patterns or trends that may help resolve the incident.
- Prioritizing: Once the symptoms have been identified, the next step is to prioritize the incident based on its impact on the user and the business.
- Assigning: After the incident has been prioritized, it is assigned to a support team that will handle it. If the support team cannot handle the incident, it is escalated to a higher-level tier.
- Escalating: If the incident requires more advanced expertise or resources, it is escalated to a higher-level tier where it can be resolved more effectively.
- Resolving: The support team or higher-level tier works on resolving the incident and provides updates to the user until the issue is resolved.
- Closing: Once the incident has been resolved, the ticket is closed by logging the resolution and changing the ticket status to indicate that the incident has been successfully resolved.
Summary
Ticketing systems are essential for businesses that want to manage customer service requests efficiently. These systems allow customers to submit service requests, track the progress of their requests, and receive updates when their requests are resolved. The ticketing system also enables businesses to assign service requests to the appropriate employees or teams and prioritize them based on urgency or severity. This helps streamline workflow and ensure service requests are addressed promptly and efficiently. Additionally, ticketing systems can provide valuable insights into customer behavior, allowing businesses to identify areas where they can improve their products or services.
]]>Health insurers today are navigating intense technological and regulatory requirements, along with rising consumer demand for seamless digital experiences. Leading organizations are investing in advanced technologies and automations to modernize operations, streamline experiences, and unlock reliable insights. By leveraging scalable infrastructures, you can turn data into a powerful tool that accelerates business success.
IDC Market Glance: Payer, 1Q25
Perficient is proud to be included in the IDC Market Glance: Payer, 1Q25 (doc#US53200825, March 2025) report for the second year in a row. According to IDC, this report “provides a glance at the current makeup of the payer IT landscape, illustrates who some of the major players are, and depicts the segments and structure of the market.”
Perficient is included in the categories of IT Services and Data Platforms/Interoperability. IDC defines the IT Services segment as, “Systems integration organizations providing advisory, consulting, development, and implementation services. Some IT Services firms also have products/solutions.” The Data Platforms/Interoperability segment is defined by IDC as, “Firms that provide data, data aggregation, data translation, data as a service and/or analytics solutions; either as off-premise, cloud, or tools on premise used for every aspect of operations.”
Discover Strategic Investments for Innovation and Success
Our strategists are committed to driving innovative solutions and guiding insurers on their digital transformation journey. We feel that our inclusion in this report reinforces our expertise in leveraging digital capabilities to unlock personalized experiences and drive greater operational efficiencies with our clients’ highly regulated, complex healthcare data.
The ten largest health insurers in the United States have counted on us to help drive the outcomes that matter most to businesses and consumers. Our experts can help you pragmatically and confidently navigate the intense regulatory requirements and consumer trends influencing digital investments. Learn more and contact us to discover how we partner to boost efficiencies, elevate health outcomes, and create differentiated experiences that enhance consumer trust.
]]>In the new episode of the “What If? So What?” podcast, Jim Hertzfeld and Deena Piquion, chief growth and disruption officer at Xerox, discuss how disruption and digital transformation can position companies to succeed in a rapidly changing technology landscape.
Deena is leading Xerox on a unique and pivotal reinvention journey as the company undergoes a significant transformation, expanding beyond its traditional print and copy services. Deena explains how the company is now focusing on enabling the modern workforce with AI-powered platforms, workflow automation, and IT solutions.
Data plays a crucial role in Xerox’s digital transformation strategy and highlights the importance of integrating data from various sources to create a unified view that enables better decision-making and more effective marketing.
Listen to the podcast to hear more about internal disruption and digital innovation!
Listen now on your favorite podcast platform or visit our website.
Subscribe Where You Listen
Apple | Spotify | Amazon | Overcast
Meet our Guest
Deena Piquion, Chief Growth and Disruption Officer, Xerox
Deena Piquion is chief growth and disruption officer at Xerox. She previously served as chief marketing officer, and senior vice president and general manager of Xerox Latin America operations. Prior to joining Xerox in 2019, she was with Tech Data Corporation, where she last served as vice president and general manager of Latin America & Caribbean.
She is a member of the Advisory Board of Teach for America Miami Dade County, a nonprofit organization dedicated to educational equity and excellence. Deena was awarded the Florida Diversity Council Glass Ceiling Award in 2016, was selected as a CRN Women of the Channel Honoree in 2017, and was named to Diversity First’s Top 50 Women in Tech 2021 and Top 100 CMOs in 2022.
Deena is actively engaged in her community and passionate about supporting children’s cancer research, and diversity and inclusion in technology. She is a dynamic blogger who created her own branded platform to share tips on personal and professional growth with an engaged following in the industry.
Connect with Deena
Meet the Host
Jim Hertzfeld is Area Vice President, Strategy for Perficient.
For over two decades, he has worked with clients to convert market insights into real-world digital products and customer experiences that actually grow their business. More than just a strategist, Jim is a pragmatic rebel known for challenging the conventional and turning grand visions into actionable steps. His candid demeanor, sprinkled with a dose of cynical optimism, shapes a narrative that challenges and inspires listeners.
]]>Today in our “We Are Perficient” series, we explore how businesses can take their digital experience to the next level through mobile optimization. In an exclusive conversation with Jonathan Crockett, Managing Director of Go-To-Market, Sales, and Solutions at Perficient, we dive into key strategies to ensure brands deliver seamless, high-impact experiences on mobile devices.
In today’s digital world, user experience is everything. Companies looking to stand out must provide seamless, personalized, and optimized interactions at every touchpoint. In this video, we explore how the combination of Artificial Intelligence, advanced digital experience strategies, and collaboration with technology leaders like Adobe is redefining the way brands connect with their customers.
Optimizing for a Mobile-First World
Today, most digital interactions happen on mobile devices. Without a well-optimized mobile strategy, brands risk losing conversions and engagement. From ultra-fast loading times to intuitive and accessible interfaces, mobile optimization is no longer optional—it’s essential to improving customer retention and conversion rates.
AI-Driven Personalization
Artificial intelligence is transforming user experiences by enabling real-time personalization based on data. From content recommendations to adaptive interfaces that respond to user behavior, AI helps deliver unique and relevant experiences at every interaction. This not only enhances customer satisfaction but also boosts lifetime value and brand loyalty.
Adobe and the Digital Strategies Evolution
As an Adobe strategic partner, Perficient helps businesses unlock the full potential of Adobe’s cutting-edge solutions. From Adobe Experience Manager to Adobe Sensei, our strategies merge creativity and technology to design immersive, scalable, and highly effective digital experiences.
Ready to Take Your Digital Strategies to the Next Level?
The future of digital experience lies in personalization, optimization, and continuous innovation. If you’re looking to transform how your customers interact with your brand, Perficient can help.
Contact us today and discover how we can elevate your digital strategy.
]]>Applying FinOps concepts to your cloud consumption is not new. It’s often treated as an IT hygiene task: necessary but not strategic. And while cost optimization and waste reduction are worthy efforts, it’s all too common to see these activities fall victim to higher daily priorities. When they are in focus, it’s often attempted by looking for low-hanging wins using cloud-native services that aren’t overly interested in delivering a comprehensive picture of cloud spend. It’s just one of those activities that is hard to get too excited about.
I challenge us to reboot this thinking with a fresh, outcome-focused perspective:
First, let’s expand FinOps to consider the bigger picture of technology spending, which the FinOps Foundation calls “Cloud+” in its 2025 State of FinOps Report (https://data.finops.org). Complexity is increasing: multicloud and hybrid environments are the norm. Real technology spend includes observability tools, containers, data platforms, SaaS licensing, AI/ML, and peripheral services, sometimes hand-waved away as shadow IT or just life as part of an unavoidable cost center. The more we can pull in these broader costs, the more accurate our insight into technology investments. Which leads us to…
Second, let’s start thinking about Unit Economics. This is a challenge, and only a small percentage of organizations fully get there, but the business payoff in shifting to this mindset can bring immediate business performance results, well beyond just optimizing public cloud infrastructure. The story we need to tell in FinOps isn’t “How much are we spending?”; it’s whether we are profiting from our investments and understanding the impact on revenue and margin if cost drivers change. Let’s make sure every dollar spent is a good dollar aligned to business objectives. Controlling costs is necessary. Maximizing value is strategic.
Measuring What Matters
Unit Economics is about shifting focus—from tracking aggregate cloud spend to measuring value at the most meaningful level: per transaction, per customer, per workload, or per outcome. These metrics bridge the gap between cloud consumption and business impact, aligning technology decisions with revenue, profitability, customer experience, and other key performance indicators.
Unlike traditional IT financials, unit economic metrics are built to reflect how your business actually operates. They unify Finance, Engineering, and Product teams around shared goals, fostering a mindset where cost efficiency and value creation go hand in hand. When used effectively, these metrics inform everything from financial forecasting, product planning, digital strategy, M&A onboarding, and feature delivery—turning cloud from a cost center into a competitive advantage.
Asking the Right Questions
Establishing effective unit economics begins with curiosity, a willingness to think differently, and meaningful collaboration. Consider these exploratory questions:
- Do we have the right visibility into our overall technical spend?
- Does it feel like there has to be a better way to do this?
- How mature are our tagging, cost allocation, and mapping practices?
- Can we define measures that reflect our company’s business performance goals?
- Are Finance, Product, and Engineering collaborating on goals, reporting, and forecasting?
- Do we have the right tools to build a complete picture of technology value as we scale?
From Cost to Value: The Unit Economics Flow
To put unit economics into action, organizations can follow this basic flow:
- Collect cloud and technology cost data across hybrid infrastructure, marketing, SaaS, and 3rd party tools
- Allocate costs to business segments such as products, BU teams, or delivered services
- Define units of value that reflect relevant and meaningful business outcomes
- Integrate with business systems to leverage financial, sales & marketing, labor, and performance metrics
- Calculate and normalize unit metrics across products, departments, and regions
- Visualize, monitor, and act through dashboards, forecasts, and optimization reviews
This approach is a baseline for moving towards more informed decisions and the potential impact of future investments.
Maturing Unit Economics with Apptio Cloudability Intelligence
Technology alone doesn’t solve this challenge, but the right platform accelerates the journey. We leverage Apptio Cloudability to bring at-scale intelligence and automation to financial operating models. With Cloudability, our clients can:
- Automate cost allocation using advanced tagging, showback, and chargeback models
- Visualize unit cost metrics by product, application, or team
- Simplify visibility into multicloud and container-based environments
- Forecast spend using trends and usage patterns tied to real business activity
- Detect cost anomalies and surface optimization recommendations
- Track and benchmark progress on key metrics like Cost per Customer or Revenue per Technology Dollar
Our goal is to bring the right intelligence to fit your business strategy, not just your IT infrastructure, delivering insights into your everyday operating model and reinforcing a culture of accountability and shared ownership. Challenge yourself to change your mindset on cost vs. value and see how unit economics can drive impactful outcomes to your organization.
]]>In the latest episode of the “What If? So What?” podcast, Jim Hertzfeld speaks with Andi Orzehoski, director of brand content and digital communications at LyondellBasell. Andi shares her expertise on sustainability, digital transformation, and the critical role of change management in driving business success.
The concept of a circular economy is one of the key topics discussed. Andi emphasizes the importance of extending the lifecycle of materials through recycling and reusing, ultimately contributing to a more sustainable future.
Andi’s role at LyondellBasell entails overseeing brand content and digital communications. She explains how these elements are interconnected and essential for delivering a cohesive customer experience.
In the digital age, even traditional B2B companies must embrace transformation. Andi explains how digital tools and platforms play a crucial role in LyondellBassell’s operations, from interacting with customers to achieving sustainability goals. She stresses the need for businesses to stay current with digital trends to remain competitive.
Finally, Andi and Jim discuss how effective communication and strategic planning are vital for successful adoption of new initiatives. By understanding the human psychology behind change, businesses can navigate challenges and drive meaningful progress.
Want to learn more? Tune in to the full episode of “What If? So What?”
Listen now on your favorite podcast platform or visit our website.
Subscribe Where You Listen
Apple | Spotify | Amazon | Overcast
Meet our Guest
Andi Orzehoski, Director of Brand Content and Digital Communications at LyondellBasell
Andi Orzehoski is a seasoned digital marketing, communications, and content strategist who is supremely passionate about innovation and team building, enhancing operations, and fostering creativity.
She serves as the director of brand, content and digital communications at LyondellBasell, a leader in the global chemical industry. Andi has worked in-house and as a consultant for organizations across industries, corporate functions, and locations, and has been integral to developing, implementing, and scaling successful teams and programs in complex and highly regulated markets.
Connect with Andi
Meet the Host
Jim Hertzfeld is Area Vice President, Strategy for Perficient.
For over two decades, he has worked with clients to convert market insights into real-world digital products and customer experiences that actually grow their business. More than just a strategist, Jim is a pragmatic rebel known for challenging the conventional and turning grand visions into actionable steps. His candid demeanor, sprinkled with a dose of cynical optimism, shapes a narrative that challenges and inspires listeners.
]]>